From 6c457792381badaa788b188b102a0233da176fb0 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sat, 17 Jan 2026 17:30:17 -0500 Subject: [PATCH 1/9] Remove redundant push ecxs for faster adds/subs. Also move from rep movsd to rep movsb, which should be faster on modern hardware. --- src/occ/gen.cpp | 47 +++++++++++++++++------------------------------ 1 file changed, 17 insertions(+), 30 deletions(-) diff --git a/src/occ/gen.cpp b/src/occ/gen.cpp index e7afb220a..94423f48f 100644 --- a/src/occ/gen.cpp +++ b/src/occ/gen.cpp @@ -705,7 +705,7 @@ void getAmodes(Optimizer::QUAD* q, enum e_opcode* op, Optimizer::IMODE* im, AMOD { *op = op_mov; *aph = 0; - if (im->mode == Optimizer::i_direct && im->offset->type == Optimizer::se_threadlocal) + if (im->mode == Optimizer::i_direct && im->offset->type == Optimizer::se_threadlocal) { AMODE* temp = setSymbol("__TLSINITSTART"); temp->mode = am_immed; @@ -789,7 +789,7 @@ void getAmodes(Optimizer::QUAD* q, enum e_opcode* op, Optimizer::IMODE* im, AMOD *aph = beLocalAllocate(); **aph = **apl; (*aph)->offset = Optimizer::simpleExpressionNode(Optimizer::se_add, (*apl)->offset, - Optimizer::simpleIntNode(Optimizer::se_i, imaginary_offset(im->size))); + Optimizer::simpleIntNode(Optimizer::se_i, imaginary_offset(im->size))); if ((*apl)->preg >= 0) (*apl)->liveRegs |= 1 << (*apl)->preg; if ((*apl)->sreg >= 0) @@ -1003,7 +1003,7 @@ void bit_store(AMODE* dest, AMODE* src, int size, int bits, int startbit) gen_codes(op_and, size, dest, aimmed(~(((1 << bits) - 1) << startbit))); } dest->liveRegs = l; - gen_codes(op_or, size, dest, aimmed((src->offset->i & ((bits == 32 ? 0 : (1 << bits)) - 1)) << startbit)); + gen_codes(op_or, size, dest, aimmed((src->offset->i & ((bits == 32 ? 0 : (1 << bits)) - 1)) << startbit)); } } else @@ -4588,7 +4588,9 @@ void asm_swbranch(Optimizer::QUAD* q) /* case characteristics */ } } void asm_dc(Optimizer::QUAD* q) /* unused */ { (void)q; } -void asm_assnblock(Optimizer::QUAD* q) /* copy block of memory*/ +/// @brief Assign one block of memory to another, typically used with an assignment operator, but not for more generaly copying +/// @param q Quad representing the assignment of a block of memory in IR +void asm_assnblock(Optimizer::QUAD* q) { int n = q->ans->offset->i; AMODE *apl = nullptr, *aph = nullptr, *apal = nullptr, *apah = nullptr; @@ -4727,6 +4729,10 @@ void asm_assnblock(Optimizer::QUAD* q) /* copy block of memory*/ pushlevel -= 4; } } + // TODO: add an extra parameter to call out to _memcpy at this and larger sizes + // Allows memcpy to be expensive per-platform + // Maybe arch-specific callouts too to prevent needing as much platform checking and allowing even better opts at the cost of + // more lib maintenance? else { AMODE* cx = makedreg(ECX); @@ -4758,14 +4764,10 @@ void asm_assnblock(Optimizer::QUAD* q) /* copy block of memory*/ gen_codes(opa, ISZ_UINT, di, apal); gen_codes(op, ISZ_UINT, si, apl); } - gen_codes(op_mov, ISZ_UINT, cx, aimmed(n / 4)); + gen_codes(op_mov, ISZ_UINT, cx, aimmed(n)); gen_code(op_cld, 0, 0); gen_code(op_rep, 0, 0); - gen_code(op_movsd, 0, 0); - if (n & 2) - gen_code(op_movsw, 0, 0); - if (n & 1) - gen_code(op_movsb, 0, 0); + gen_code(op_movsb, 0, 0); gen_codes(op_pop, ISZ_UINT, cx, 0); gen_codes(op_pop, ISZ_UINT, si, 0); gen_codes(op_pop, ISZ_UINT, di, 0); @@ -5075,14 +5077,14 @@ void asm_jg(Optimizer::QUAD* q) /* branch if a S> b */ { gen_goto(q, op_jg, op_j void asm_jle(Optimizer::QUAD* q) /* branch if a S<= b */ { gen_goto(q, op_jle, op_jge, op_jl, op_jg, op_jbe, op_jae, op_jbe); } void asm_jge(Optimizer::QUAD* q) /* branch if a S>= b */ { gen_goto(q, op_jge, op_jle, op_jg, op_jl, op_jae, op_jbe, op_jae); } void asm_cppini(Optimizer::QUAD* q) /* cplusplus initialization (historic)*/ { (void)q; } -/* +/** * function prologue. left has a constant which is a bit mask * of registers to push. It also has a flag indicating whether frames * are absolutely necessary * * right has the number of bytes to allocate on the stack */ -void asm_prologue(Optimizer::QUAD* q) /* function prologue */ +void asm_prologue(Optimizer::QUAD* q) { inframe = !!(beGetIcon(q->dc.left) & FRAME_FLAG_NEEDS_FRAME) || Optimizer::cparams.prm_debug || Optimizer::cparams.prm_stackalign; @@ -5115,15 +5117,9 @@ void asm_prologue(Optimizer::QUAD* q) /* function prologue */ pushlevel = 0; if (n) { - if (n < 16) - { - int i; - for (i = 0; i < n; i += 4) - gen_codes(op_push, ISZ_UINT, makedreg(ECX), 0); - } - else if (n <= 4092) + if (n <= 4092) { - gen_code(op_add, makedreg(ESP), aimmed(-n)); + gen_code(op_sub, makedreg(ESP), aimmed(n)); } else { @@ -5194,16 +5190,7 @@ void asm_epilogue(Optimizer::QUAD* q) /* function epilogue */ { if (usingEsp) { - if (funcstackheight <= 16) - { - int i; - for (i = 0; i < funcstackheight; i += 4) - gen_codes(op_pop, ISZ_UINT, makedreg(ECX), 0); - } - else - { - gen_code(op_add, makedreg(ESP), aimmed(funcstackheight)); - } + gen_code(op_add, makedreg(ESP), aimmed(funcstackheight)); } else { From 0060102b542f357c182e7bba2be557dc57f20649 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sat, 17 Jan 2026 20:33:54 -0500 Subject: [PATCH 2/9] Make _bcopy a stub for _memmove --- src/clibs/strings/386/bcopy.nas | 44 +++++++++++++-------------------- 1 file changed, 17 insertions(+), 27 deletions(-) diff --git a/src/clibs/strings/386/bcopy.nas b/src/clibs/strings/386/bcopy.nas index ec1f5360f..39082eac6 100644 --- a/src/clibs/strings/386/bcopy.nas +++ b/src/clibs/strings/386/bcopy.nas @@ -25,31 +25,21 @@ [export _bcopy] %endif [global _bcopy] - -[extern memcpy_x] - -SECTION code CLASS=CODE USE32 +[extern _memmove] _bcopy: - push ebp - mov ebp, esp - push ebx - mov ecx,[ebp+16] - jecxz x1 - mov edx,[ebp+12] - mov ebx,[ebp+8] -join: - cmp edx,ebx - jbe memcpy_x - add ebx,ecx - add edx,ecx -lp2: - dec ebx - dec edx - mov al,[ebx] - mov [edx],al - loop lp2 -x1: - mov eax,edx - pop ebx - pop ebp - ret +; void bcopy(const void* src, void* dest, size_t n) { memmove(dest, src, n); } +; We want to order it so that we grab the 2nd param, then the first param, then the last param +; Remember, order is from RTL +; 3 pushes == 4 bytes on stack +; Current location of src is esp+04 +; Current location of dest is esp+08 +; Current location of n is esp+12 +; Grab n and push it onto the stack + push dword [esp+0ch+00h] +; Grab src and put it onto the stack, remember, we just pushed to the stack, so add 4 + push dword [esp+04h+04h] +; Grab dest and push it to the stack + push dword [esp+08h+08h] + call _memmove ; memmove + add esp,byte 0ch + ret \ No newline at end of file From a26c1855aab4ad463b39623c6e1b8d4b0346bb29 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sun, 18 Jan 2026 09:34:37 -0500 Subject: [PATCH 3/9] Edit memcpy to be based off of my reference memcpy implementation. --- src/clibs/string/386/memcpy.c.refsrc | 79 ++++++++++++ src/clibs/string/386/memcpy.nas | 185 ++++++++++++++++++++------- src/clibs/string/386/memmove.nas | 55 -------- 3 files changed, 221 insertions(+), 98 deletions(-) create mode 100644 src/clibs/string/386/memcpy.c.refsrc delete mode 100644 src/clibs/string/386/memmove.nas diff --git a/src/clibs/string/386/memcpy.c.refsrc b/src/clibs/string/386/memcpy.c.refsrc new file mode 100644 index 000000000..77e8075b7 --- /dev/null +++ b/src/clibs/string/386/memcpy.c.refsrc @@ -0,0 +1,79 @@ +#include +inline void* memcpy_basic(void* dest, const void* src, size_t n) +{ + for (size_t i = 0; i < n; i++) + { + ((char*)dest)[i] = ((const char*)src)[i]; + } + return dest; +} +inline void* memmove_backwards_basic(void* s1, const void* s2, size_t sz) +{ + while (sz > 0) + { + sz--; + ((char*)s1)[sz] = ((const char*)s2)[sz]; + } + return s1; +} +inline void* memmove_backwards(void* s1, const void* s2, size_t sz) +{ + if (sz < 256) + { + return memmove_backwards_basic(s1, s2, sz); + } + char* src_end = (const char*)s2 + sz; + char* dest_end = (const char*)s1 + sz; + __asm + { + // If DF=1 ESI and EDI are subtracted each time, otherwise ESI and EDI are added to. + mov esi, [src_end]; + mov edi, [dest_end]; + mov ecx, [sz]; + std; + rep movsb; + cld; + } + return s1; +} +inline void* memcpy_repmovs(void* s1, const void* s2, size_t sz) +{ + // Garbage heuristic, check 3.7.6.3 of the Intel Architecture Optimization manual. + // In theory, once we confirm that this "style" is faster, an optimization pass to make the function absolutely tiny is + // available + if (sz < 256) + { + return memcpy_basic(s1, s2, sz); + } + __asm + { + mov esi, [s2]; + mov edi, [s1]; + mov ecx, [sz]; + cld; + rep movsb; + } + return s1; +} + +void* _RTL_FUNC memcpy(void* dest, const void* src, size_t sz) +{ + // Do we overlap? + if (((uintptr_t)src) < ((uintptr_t)dest) && ((uintptr_t)dest) < (((uintptr_t)src) + sz)) + { + size_t distance_beyond = ((uintptr_t)src) + sz - ((uintptr_t)dest); + size_t inverse_distance_beyond = sz - distance_beyond; + memmove_backwards_basic((char*)dest + inverse_distance_beyond, dest, distance_beyond); + // Copy the values in-between dest and src to dest + return memcpy_repmovs(dest, src, inverse_distance_beyond); + } + else + { + // Destination + size goes into source + // That is fine, we can do a forward copy without issue + return memcpy_repmovs(dest, src, sz); + } + return dest; +} + +void* _RTL_FUNC memmove(void* dest, const void* src, size_t n) { return memcpy(dest, src, n); } \ No newline at end of file diff --git a/src/clibs/string/386/memcpy.nas b/src/clibs/string/386/memcpy.nas index 952fa7547..96fcaad46 100644 --- a/src/clibs/string/386/memcpy.nas +++ b/src/clibs/string/386/memcpy.nas @@ -23,51 +23,150 @@ %ifdef __BUILDING_LSCRTL_DLL [export _memcpy] +[export _memmove] %endif [global _memcpy] -[global memcpy_x] +[global _memmove] SECTION code CLASS=CODE USE32 +; memcpy_basic +_memcpy_basic: +; Line 2: inline void* memcpy_basic(void* dest, const void* src, size_t n) + push ebx + push esi + push edi + mov esi,dword [esp+0ch+0ch] + mov edx,dword [esp+08h+0ch] + mov eax,dword [esp+04h+0ch] +; Line 4: for (size_t i = 0; i < n; i++) + xor ebx,ebx + cmp ebx,esi + jnc L_6 +L_4: +; Line 5: { +; Line 6: ((char*)dest)[i] = ((const char*)src)[i]; + mov cl,byte [edx+ebx] + mov byte [eax+ebx],cl +; Line 7: } + inc ebx +L_5: + cmp ebx,esi + jc L_4 +L_6: +; Line 8: return dest; +; Line 9: } + pop edi + pop esi + pop ebx + ret +; memcpy_repmovs +_memcpy_repmovs: +; Line 39: inline void* memcpy_repmovs(void* s1, const void* s2, size_t sz) + cmp dword [esp+0ch],0100h + jl _memcpy_basic + push esi + push edi +; Line 48: __asm +; Line 49: { + mov esi,dword [esp+08h+08h] +; Line 50: mov esi, [s2]; +; Line 51: mov edi, [s1]; + mov edi,dword [esp+04h+08h] +; Line 52: mov ecx, [sz]; + mov ecx,dword [esp+0ch+08h] +; Line 53: cld; + cld +; Line 54: rep movsb; + rep movsb +; Line 55: } +; Line 56: return s1; + mov eax,dword [esp+04h+08h] +; Line 57: } + pop edi + pop esi + ret +; memcpy +_memmove: _memcpy: - push ebp - mov ebp, esp - push ebx - mov ecx,[ebp+ 16] - jecxz x2 - mov edx,[ebp+8] - mov ebx,[ebp+12] -memcpy_x: ; from MEMMOVE - dec edx -lp1: - inc edx - test dl,3 - jz lp - mov al,[ebx] - inc ebx - mov [edx],al - loop lp1 - jecxz x2 -lp: - cmp ecx,BYTE 4 - jb c1 - mov eax,[ebx] - add ebx,BYTE 4 - mov [edx],eax - sub ecx,BYTE 4 - add edx,BYTE 4 - jmp short lp -c1: - jecxz x2 - dec edx -lp2: - inc edx - mov al,[ebx] - inc ebx - mov [edx],al - loop lp2 -x2: - mov eax,[esp+8] - pop ebx - pop ebp - ret - \ No newline at end of file +; Line 59: void* _RTL_FUNC memcpy(void* dest, const void* src, size_t sz) + sub esp,byte 014h + push ebx + push ebp + push esi + push edi +L_78: + mov ebx,dword [esp+0ch+024h] + mov eax,dword [esp+08h+024h] + mov dword [esp-010h+024h],eax + mov edi,dword [esp+04h+024h] +; Line 62: if (((uintptr_t)src) < ((uintptr_t)dest) && ((uintptr_t)dest) < (((uintptr_t)src) + sz)) + mov eax,edi + mov esi,edi + mov edx,dword [esp-010h+024h] + mov ecx,dword [esp-010h+024h] + cmp ecx,esi + jnc L_81 + mov ecx,edx + add ecx,ebx + mov dword [esp-014h+024h],ecx + mov ebp,eax + mov esi,ebx + cmp ebp,dword [esp-014h+024h] + jnc L_81 +; Line 63: { +; Line 64: size_t distance_beyond = ((uintptr_t)src) + sz - ((uintptr_t)dest); + add edx,esi + mov ecx,eax + sub ecx,edx + neg ecx +; Line 65: size_t inverse_distance_beyond = sz - distance_beyond; + sub esi,ecx +; Line 66: memmove_backwards_basic((char*)dest + inverse_distance_beyond, dest, distance_beyond); + mov ebx,eax + add ebx,esi +; Line 12: while (sz > 0) +L_100: + cmp ecx,byte 00h + jbe L_97 +L_96: +; Line 13: { +; Line 14: sz--; + dec ecx + mov dl,byte [eax+ecx] + mov byte [ebx+ecx],dl +; Line 15: ((char*)s1)[sz] = ((const char*)s2)[sz]; +L_98: + cmp ecx,byte 00h + ja L_96 +L_97: +; Line 16: } +; Line 17: return s1; +; Line 18: } +; Line 68: return memcpy_repmovs(dest, src, inverse_distance_beyond); + push esi + mov eax,dword [esp-010h+028h] + push eax + push edi + call _memcpy_repmovs ; memcpy_repmovs + add esp,byte 0ch + jmp L_79 +; Line 69: } +L_81: +; Line 70: else +; Line 71: { +; Line 74: return memcpy_repmovs(dest, src, sz); + push ebx + mov eax,dword [esp-010h+028h] + push eax + push edi + call _memcpy_repmovs ; memcpy_repmovs + add esp,byte 0ch +; Line 75: } +L_86: +L_79: + pop edi + pop esi + pop ebp + pop ebx + add esp,byte 014h + ret diff --git a/src/clibs/string/386/memmove.nas b/src/clibs/string/386/memmove.nas deleted file mode 100644 index ac4ea9451..000000000 --- a/src/clibs/string/386/memmove.nas +++ /dev/null @@ -1,55 +0,0 @@ -; Software License Agreement -; -; Copyright(C) 1994-2025 David Lindauer, (LADSoft) -; -; This file is part of the Orange C Compiler package. -; -; The Orange C Compiler package is free software: you can redistribute it and/or modify -; it under the terms of the GNU General Public License as published by -; the Free Software Foundation, either version 3 of the License, or -; (at your option) any later version. -; -; The Orange C Compiler package is distributed in the hope that it will be useful, -; but WITHOUT ANY WARRANTY; without even the implied warranty of -; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -; GNU General Public License for more details. -; -; You should have received a copy of the GNU General Public License -; along with Orange C. If not, see . -; -; contact information: -; email: TouchStone222@runbox.com -; - -%ifdef __BUILDING_LSCRTL_DLL -[export _memmove] -%endif -[global _memmove] - -[extern memcpy_x] - -section code CLASS=CODE USE32 -_memmove: - push ebp - mov ebp, esp - push ebx - mov ecx,[ebp+16] - jecxz x1 - mov ebx,[ebp+12] - mov edx,[ebp+8] -join: - cmp edx,ebx - jbe memcpy_x - add ebx,ecx - add edx,ecx -lp2: - dec ebx - dec edx - mov al,[ebx] - mov [edx],al - loop lp2 -x1: - mov eax,[esp+8] - pop ebx - pop ebp - ret From 9c28e1dfb4126e6927613ee0159e1874b5c835a2 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Wed, 21 Jan 2026 08:00:53 -0500 Subject: [PATCH 4/9] Change has_single_bit to rid ourselves of the loop while not using `popcount`. --- src/clibs/stdbit/has_single_bit.cpp | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/clibs/stdbit/has_single_bit.cpp b/src/clibs/stdbit/has_single_bit.cpp index 3d3833cb1..593aca1d3 100644 --- a/src/clibs/stdbit/has_single_bit.cpp +++ b/src/clibs/stdbit/has_single_bit.cpp @@ -26,11 +26,9 @@ #include template -static inline unsigned int has_single_bit(T arg) +static inline bool has_single_bit(T arg) { - int rv = 0; - for (T val = ((T)1) << sizeof(arg) * CHAR_BIT - 1; val; rv += (arg & val) != 0, val >>= 1); - return rv == 1; + return arg && !(arg & (arg - 1)); } extern "C" From a8e9691dbaa06639655fb23310ee15680a5a0f9e Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sun, 25 Jan 2026 20:36:18 -0500 Subject: [PATCH 5/9] Remove a couple of extraneous movs when they can be direct pushes. --- src/clibs/string/386/memcpy.nas | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/clibs/string/386/memcpy.nas b/src/clibs/string/386/memcpy.nas index 96fcaad46..17104448e 100644 --- a/src/clibs/string/386/memcpy.nas +++ b/src/clibs/string/386/memcpy.nas @@ -90,6 +90,10 @@ _memmove: _memcpy: ; Line 59: void* _RTL_FUNC memcpy(void* dest, const void* src, size_t sz) sub esp,byte 014h +; dest location: 04h +; src location: 08h +; size location: 0ch +; Stack size: 4 * 4 + 14h = 24h push ebx push ebp push esi @@ -144,8 +148,7 @@ L_97: ; Line 18: } ; Line 68: return memcpy_repmovs(dest, src, inverse_distance_beyond); push esi - mov eax,dword [esp-010h+028h] - push eax + push dword [esp-010h+028h] push edi call _memcpy_repmovs ; memcpy_repmovs add esp,byte 0ch @@ -156,8 +159,7 @@ L_81: ; Line 71: { ; Line 74: return memcpy_repmovs(dest, src, sz); push ebx - mov eax,dword [esp-010h+028h] - push eax + push dword [esp-010h+028h] push edi call _memcpy_repmovs ; memcpy_repmovs add esp,byte 0ch From 1aaf1334e4073e9aec3f822e2db735604d0027c9 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sun, 25 Jan 2026 20:37:19 -0500 Subject: [PATCH 6/9] Minor removal of evaluating + on strings in logging functions. --- src/omake/Depends.cpp | 2 +- src/omake/Depends.h | 2 +- src/omake/Eval.cpp | 16 ++++++++-------- src/omake/JobServer.cpp | 10 ++++------ src/omake/Runner.cpp | 4 ++-- src/omake/Spawner.cpp | 21 ++++++++++++--------- src/omake/os.cpp | 14 ++++++++------ 7 files changed, 36 insertions(+), 33 deletions(-) diff --git a/src/omake/Depends.cpp b/src/omake/Depends.cpp index bc4c32597..f95f8b4ce 100644 --- a/src/omake/Depends.cpp +++ b/src/omake/Depends.cpp @@ -25,4 +25,4 @@ #include "Depends.h" #include "BasicLogging.h" -Depends::~Depends() { OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Depends with goal: " + this->GetGoal() + " is being destructed"); } +Depends::~Depends() { OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Depends with goal: ", this->GetGoal(), " is being destructed"); } diff --git a/src/omake/Depends.h b/src/omake/Depends.h index e2243d698..6aea27f14 100644 --- a/src/omake/Depends.h +++ b/src/omake/Depends.h @@ -51,7 +51,7 @@ class Depends ignoreResults(false) { OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, - "Depends with goal: " + this->GetGoal() + " is being destructed"); + "Depends with goal: ", this->GetGoal(), " is being destructed"); } ~Depends(); diff --git a/src/omake/Eval.cpp b/src/omake/Eval.cpp index ec26ef845..43e33bd76 100644 --- a/src/omake/Eval.cpp +++ b/src/omake/Eval.cpp @@ -113,11 +113,11 @@ void Eval::Clear() std::string Eval::Evaluate() { - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Eval::Evaluate called with str: " + str); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Eval::Evaluate called with str: ", str); std::string rv = ParseMacroLine(str); if (expandWildcards) rv = wildcardinternal(rv); - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Eval::Evaluate called with str: " + str); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Eval::Evaluate called with str: ", str); return rv; } @@ -1190,7 +1190,7 @@ std::string Eval::notdir(const std::string& names) rv += " "; rv += intermed; } - OrangeC::Utils::BasicLogger::debug("Eval::notdir with Original name: " + names + " evaluated names " + working + " returns: " + rv); + OrangeC::Utils::BasicLogger::debug("Eval::notdir with Original name: ", names, " evaluated names ", working, " returns: ", rv); return rv; } @@ -1290,7 +1290,7 @@ std::string Eval::addprefix(const std::string& arglist) std::string Eval::wildcard(const std::string& arglist) { - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Called Eval::wildcard with argslist: " + arglist); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Called Eval::wildcard with argslist: ", arglist); std::string names = strip(arglist); std::string rv; @@ -1305,13 +1305,13 @@ std::string Eval::wildcard(const std::string& arglist) rv += current; } } - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Returning from Eval::wildcard: " + rv); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Returning from Eval::wildcard: ", rv); return rv; } std::string Eval::wildcardinternal(std::string& names) { - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Called Eval::wildcardinternal with argslist: " + names); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Called Eval::wildcardinternal with argslist: ", names); CmdFiles files; while (!names.empty()) { @@ -1325,7 +1325,7 @@ std::string Eval::wildcardinternal(std::string& names) rv += " "; rv += name; } - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Returning from Eval::wildcardinternal: " + rv); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3,"Returning from Eval::wildcardinternal: ", rv); return rv; } @@ -1492,7 +1492,7 @@ std::string Eval::foreach (const std::string& arglist) std::string Eval::call(const std::string& arglist) { - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Called Eval::call with argslist: " + arglist); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Called Eval::call with argslist: ", arglist); std::string sub = arglist; std::string args; std::string rv; diff --git a/src/omake/JobServer.cpp b/src/omake/JobServer.cpp index 745ece831..edc546e16 100644 --- a/src/omake/JobServer.cpp +++ b/src/omake/JobServer.cpp @@ -21,15 +21,13 @@ std::shared_ptr JobServer::GetJobServer(int max_jobs) int pid = getpid(); std::string omake_string = "OMAKE"; std::string combined = omake_string + std::to_string(pid); - OrangeC::Utils::BasicLogger::log(5, - "GetJobServer making new job server: " + combined + " job count: " + std::to_string(max_jobs)); + OrangeC::Utils::BasicLogger::log(5, "GetJobServer making new job server: ", combined, " job count: ", std::to_string(max_jobs)); return std::make_shared(combined, max_jobs); #else int pid = getpid(); std::string omake_string = "OMAKE"; std::string combined = omake_string + std::to_string(pid); - OrangeC::Utils::BasicLogger::log(5, - "GetJobServer making new job server: " + combined + " job count: " + std::to_string(max_jobs)); + OrangeC::Utils::BasicLogger::log(5, "GetJobServer making new job server: ", combined, " job count: ", std::to_string(max_jobs)); return std::make_shared(combined, max_jobs); #endif @@ -45,8 +43,8 @@ std::shared_ptr JobServer::GetJobServer(const std::string& auth_strin { std::string new_string = std::string(auth_string.begin() + found + strlen("auth:"), auth_string.end()); OrangeC::Utils::BasicLogger::log(OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG, - "GetJobServer(std::string) auth based, string: " + auth_string + - " new string: " + new_string); + "GetJobServer(std::string) auth based, string: ", auth_string, + " new string: ", new_string); return std::make_shared(new_string); } else diff --git a/src/omake/Runner.cpp b/src/omake/Runner.cpp index 37a17ac3a..6cceb0c0e 100644 --- a/src/omake/Runner.cpp +++ b/src/omake/Runner.cpp @@ -48,7 +48,7 @@ void Runner::CallRunner(Runner* runner, std::list>* li { auto retval = runner->RunOne(list, depend, env, keepGoing); promise.set_value(retval); - OrangeC::Utils::BasicLogger::debug("CallRunner returning from a runner: " + depend->GetGoal()); + OrangeC::Utils::BasicLogger::debug("CallRunner returning from a runner: ", depend->GetGoal()); } struct future_holding_struct { @@ -124,7 +124,7 @@ int Runner::RunOne(std::list>* ruleStack_in, Depends* { std::promise promise; workingList.push_back(future_holding_struct(depend->GetGoal(), promise.get_future())); - OrangeC::Utils::BasicLogger::debug("RunOne CallRunner Creating a runner: " + i->GetGoal()); + OrangeC::Utils::BasicLogger::debug("RunOne CallRunner Creating a runner: ", i->GetGoal()); auto thrd = std::thread(CallRunner, this, &ruleStack, i.get(), env, keepGoing, std::move(promise)); workingThreads.emplace_back(i->GetGoal(), std::move(thrd)); diff --git a/src/omake/Spawner.cpp b/src/omake/Spawner.cpp index 3e53d9075..ee316a9b4 100644 --- a/src/omake/Spawner.cpp +++ b/src/omake/Spawner.cpp @@ -80,13 +80,15 @@ static bool HasMake(const std::string& cmd, const std::string& make) { m = cmd.find_first_of(" \n\t\r\v", m + 1); } - if ( m != std::string::npos && m > n) + if (m != std::string::npos && m > n) return true; // hack for autoconfig texts which use '&& $(MAKE) ...' // a more complete solution would look for any bash operator I guess... - while (n > 0 && !isspace(cmd[n]) && cmd[n] != '&') n--; - while (n > 0 && isspace(cmd[n])) n--; - if (n > 1 && cmd[n] == '&' && cmd[n-1] == '&') + while (n > 0 && !isspace(cmd[n]) && cmd[n] != '&') + n--; + while (n > 0 && isspace(cmd[n])) + n--; + if (n > 1 && cmd[n] == '&' && cmd[n - 1] == '&') return true; } } @@ -236,11 +238,12 @@ int Spawner::Run(const std::string& cmdin, bool ignoreErrors, bool silent, bool std::string varname = OS::LookupShellNames(); if (!OS::IsUnixLikeShell(varname)) { - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Command before NormalizeFileName: ", cmdin); + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, + "Command before NormalizeFileName: ", cmdin); cmd = OS::NormalizeFileName(cmdin); - OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, "Command after NormalizeFileName: ", cmd); - + OrangeC::Utils::BasicLogger::log((int)OrangeC::Utils::VerbosityLevels::VERB_EXTREMEDEBUG + 3, + "Command after NormalizeFileName: ", cmd); } std::string make; Variable* v1 = VariableContainer::Instance()->Lookup("MAKE"); @@ -354,8 +357,8 @@ bool Spawner::split(const std::string& cmd) } std::string Spawner::shell(const std::string& cmd) { - OrangeC::Utils::BasicLogger::log(OrangeC::Utils::VerbosityLevels::VERB_WARNING, - OS::JobName() + " is running $(shell " + cmd + " )"); + OrangeC::Utils::BasicLogger::log(OrangeC::Utils::VerbosityLevels::VERB_WARNING, OS::JobName(), " is running $(shell ", cmd, + " )"); std::string rv = OS::SpawnWithRedirect(cmd); int n = rv.size(); while (n && (rv[n - 1] == '\r' || rv[n - 1] == '\n')) diff --git a/src/omake/os.cpp b/src/omake/os.cpp index cd34405a8..30eae0bd4 100644 --- a/src/omake/os.cpp +++ b/src/omake/os.cpp @@ -933,13 +933,15 @@ std::string OS::SpawnWithRedirect(const std::string command) exit_condition = (WIFEXITED(status) || WIFSTOPPED(status)); if (WIFEXITED(status)) { - OrangeC::Utils::BasicLogger::debug("Process with command: " + command + " exited. ret_wait: " + - std::to_string(ret_wait) + " status: " + std::to_string(status)); + OrangeC::Utils::BasicLogger::debug("Process with command: ", command, + " exited. ret_wait: ", std::to_string(ret_wait), + " status: ", std::to_string(status)); } if (WIFSTOPPED(status)) { - OrangeC::Utils::BasicLogger::debug("Process with command: " + command + " stopped. ret_wait: " + - std::to_string(ret_wait) + " status: " + std::to_string(status)); + OrangeC::Utils::BasicLogger::debug("Process with command: ", command, + " stopped. ret_wait: ", std::to_string(ret_wait), + " status: ", std::to_string(status)); } status = WEXITSTATUS(status); } @@ -947,8 +949,8 @@ std::string OS::SpawnWithRedirect(const std::string command) } while (!exit_condition); close(pipe_cout[0]); close(pipe_cout[1]); - OrangeC::Utils::BasicLogger::debug("OS::SpawnWithRedirect returning from command: " + command + - " with status: " + std::to_string(status)); + OrangeC::Utils::BasicLogger::debug("OS::SpawnWithRedirect returning from command: ", command, + " with status: ", std::to_string(status)); return output_str; #endif } From 4a0210128d99cd3a63b9f8746a167b58852652af Mon Sep 17 00:00:00 2001 From: chuggafan Date: Wed, 4 Feb 2026 13:58:51 -0500 Subject: [PATCH 7/9] SSE2 strlen The hot loop is now ~6 instructions as opposed to the old ~8, while doing 4x the amount of compares. Small strings may be slightly slower as the cold loop is there to align the speeds up faster, so strings < 15 in length may be slower. Anything > 32 in length should be faster compared to previously, however. --- src/adl/makefile | 5 +- src/clibs/string/386/strlen.nas | 95 +- src/oasm/AdlStructures.h | 4 +- src/oasm/x64.adl | 4 +- src/oasm/x64Instructions.cpp | 1166 +- src/oasm/x64Instructions.h | 1498 +- src/oasm/x64Operand.h | 44 +- src/oasm/x64Parser.cpp | 105523 ++++++++++++++--------------- src/oasm/x64Parser.h | 16548 ++--- src/occ/x64Parser.cpp | 105523 ++++++++++++++--------------- 10 files changed, 113818 insertions(+), 116592 deletions(-) diff --git a/src/adl/makefile b/src/adl/makefile index d8b02b0b7..76b833a01 100644 --- a/src/adl/makefile +++ b/src/adl/makefile @@ -2,7 +2,7 @@ # CC=cl.exe -CCFLAGS = /O2 /EHs /c /nologo /I../util +CCFLAGS = /O2 /EHs /c /nologo /I../util /DTARGET_OS_WINDOWS LINK=link.exe LFLAGS=/LTCG:incremental /nologo /NXCOMPAT /DYNAMICBASE /MACHINE:x86 /OPT:REF /SAFESEH /OPT:ICF /TLBID:1 @@ -21,7 +21,8 @@ EXE_dependencies = \ GenParser.obj \ Loader.obj \ Tokenizer.obj \ - ADLMain.obj + ADLMain.obj \ + ToolChain.obj adl.exe: $(EXE_dependencies) $(LINK) $(TYPE) $(LFLAGS) $(COMPLIB) /LIBPATH:"$(UCRTPATH)" /LIBPATH:"$(VCINSTALLDIR)\lib" /OUT:$@ $(EXE_dependencies) diff --git a/src/clibs/string/386/strlen.nas b/src/clibs/string/386/strlen.nas index 24a907efa..082693963 100644 --- a/src/clibs/string/386/strlen.nas +++ b/src/clibs/string/386/strlen.nas @@ -1,53 +1,54 @@ -; Software License Agreement -; -; Copyright(C) 1994-2025 David Lindauer, (LADSoft) -; -; This file is part of the Orange C Compiler package. -; -; The Orange C Compiler package is free software: you can redistribute it and/or modify -; it under the terms of the GNU General Public License as published by -; the Free Software Foundation, either version 3 of the License, or -; (at your option) any later version. -; -; The Orange C Compiler package is distributed in the hope that it will be useful, -; but WITHOUT ANY WARRANTY; without even the implied warranty of -; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -; GNU General Public License for more details. -; -; You should have received a copy of the GNU General Public License -; along with Orange C. If not, see . -; -; contact information: -; email: TouchStone222@runbox.com -; - +; This file is heavily inspired by/compiled from https://www.strchr.com/sse2_optimised_strlen +; The original code is public domain, this usage of it is, due to that basis, kept as public domain. +; It's compiled with CL with minor modifications such as explicitly laying out my no-ops +; These no-ops are taken from stack overflow on NASM no-ops https://stackoverflow.com/a/48254809 +%define nop1 nop ; just a nop, included for completeness +%define nop2 db 0x66, 0x90 ; 66 NOP +%define nop3 db 0x0F, 0x1F, 0x00 ; NOP DWORD ptr [EAX] +%define nop4 db 0x0F, 0x1F, 0x40, 0x00 ; NOP DWORD ptr [EAX + 00H] +%define nop5 db 0x0F, 0x1F, 0x44, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00H] +%define nop6 db 0x66, 0x0F, 0x1F, 0x44, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00H] +%define nop7 db 0x0F, 0x1F, 0x80, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + 00000000H] +%define nop8 db 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00000000H] +%define nop9 db 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H] %ifdef __BUILDING_LSCRTL_DLL [export _strlen] %endif [global _strlen] SECTION code CLASS=CODE USE32 _strlen: - push ebp - mov ebp, esp - mov eax,[ebp+8] - dec eax -lp1: - inc eax - test al,3 - jnz x1 -lp2: - mov ecx,[eax] - add eax,BYTE 4 - mov edx,ecx - sub edx,001010101h - not ecx - and edx,080808080h - and edx,ecx - jz lp2 - sub eax,BYTE 4 -x1: - cmp byte [eax],BYTE 0 - jne lp1 - sub eax,[ebp+8] - pop ebp - ret + mov eax, [esp+4] + xor edx, edx + test al, 15 + je SHORT hot_loop_prep + nop6 +alignment_loop: + mov cl, [eax] + inc eax + test cl, cl + je easy_exit + inc edx + test al, 15 + jne alignment_loop +hot_loop_prep: + movaps xmm0, [eax] + xorps xmm1, xmm1 + pcmpeqb xmm0, xmm1 + pmovmskb ecx, xmm0 + test ecx, ecx + jne sse_exit + sub eax, edx +hot_loop: + movaps xmm0, [eax+edx+16] + add edx, 16 + pcmpeqb xmm0, xmm1 + pmovmskb ecx, xmm0 + test ecx, ecx + je SHORT hot_loop +sse_exit: + bsf eax, ecx + add eax, edx + ret +easy_exit: + mov eax, edx + ret diff --git a/src/oasm/AdlStructures.h b/src/oasm/AdlStructures.h index 348f241f1..bc04fddcc 100644 --- a/src/oasm/AdlStructures.h +++ b/src/oasm/AdlStructures.h @@ -7,7 +7,7 @@ class AdlExprNode { public: - AdlExprNode(long long int i) : ival(i) {} + AdlExprNode(long long int i) : ival(i) { } AdlExprNode(const AdlExprNode& old) { ival = old.ival; } long long int ival; }; @@ -17,6 +17,7 @@ class BitStream public: BitStream(bool BigEndian = false) : bigEndian(BigEndian) { Reset(); } + void SetBigEndian(bool BigEndian) { bigEndian = BigEndian; } bool GetBigEndian() { return bigEndian; } @@ -44,6 +45,7 @@ enum asmError AERR_INVALIDINSTRUCTIONUSE }; + class Coding { public: diff --git a/src/oasm/x64.adl b/src/oasm/x64.adl index 922d9500e..97d0c7d25 100644 --- a/src/oasm/x64.adl +++ b/src/oasm/x64.adl @@ -2528,8 +2528,8 @@ - - + + diff --git a/src/oasm/x64Instructions.cpp b/src/oasm/x64Instructions.cpp index b870e3546..8e4fbd924 100644 --- a/src/oasm/x64Instructions.cpp +++ b/src/oasm/x64Instructions.cpp @@ -2,250 +2,930 @@ #include "x64Instructions.h" -const char* const opcodeTable[631] = { - "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "", "", "", "", - "", "", "", "", "", "aaa", "aad", "aam", "aas", - "adc", "add", "and", "arpl", "bound", "bsf", "bsr", "bswap", "bt", - "btc", "btr", "bts", "call", "cbw", "cdq", "cdqe", "clc", "cld", - "cli", "clts", "cmc", "cmova", "cmovae", "cmovb", "cmovbe", "cmovc", "cmove", - "cmovg", "cmovge", "cmovl", "cmovle", "cmovna", "cmovnae", "cmovnb", "cmovnbe", "cmovnc", - "cmovne", "cmovng", "cmovnge", "cmovnl", "cmovnle", "cmovno", "cmovnp", "cmovns", "cmovnz", - "cmovo", "cmovp", "cmovpe", "cmovpo", "cmovs", "cmovz", "cmp", "cmps", "cmpsb", - "cmpsw", "cmpsd", "cmpsq", "cmpxchg", "cmpxchg8b", "cmpxchg16b", "cpuid", "cqo", "cwd", - "cwde", "daa", "das", "dec", "div", "enter", "esc", "f2xm1", "fabs", - "fadd", "faddp", "fbld", "fbstp", "fchs", "fclex", "fnclex", "fcmovb", "fcmovbe", - "fcmove", "fcmovnb", "fcmovnbe", "fcmovne", "fcmovnu", "fcmovu", "fcom", "fcomi", "fcomip", - "fcomp", "fcompp", "fcos", "fdecstp", "fdisi", "fdiv", "fdivp", "fdivr", "fdivrp", - "feni", "ffree", "ffreep", "fiadd", "ficom", "ficomp", "fidiv", "fidivr", "fild", - "fimul", "fincstp", "finit", "fninit", "fist", "fistp", "fisub", "fisubr", "fld", - "fld1", "fldcw", "fldenv", "fldl2e", "fldl2t", "fldlg2", "fldln2", "fldpi", "fldz", - "fmul", "fmulp", "fnop", "fnsave", "fpatan", "fprem", "fprem1", "fptan", "frndint", - "frstor", "fsave", "fscale", "fsetpm", "fsin", "fsincos", "fsqrt", "fst", "fstcw", - "fnstcw", "fstenv", "fnstenv", "fstp", "fstsw", "fnstsw", "fsub", "fsubp", "fsubr", - "fsubrp", "ftst", "fucom", "fucomi", "fucomip", "fucomp", "fucompp", "fwait", "fxam", - "fxch", "fxch4", "fxch7", "fxrstor", "fxsave", "fxtract", "fyl2x", "fyl2xp1", "hlt", - "icebp", "idiv", "imul", "in", "ins", "insb", "insw", "insd", "inc", - "int", "int1", "int3", "into", "invd", "invlpg", "iret", "iretw", "iretd", - "iretq", "ja", "jae", "jb", "jbe", "jc", "jcxz", "jecxz", "je", - "jg", "jge", "jl", "jle", "jmp", "jna", "jnae", "jnb", "jnbe", - "jnc", "jne", "jng", "jnge", "jnl", "jnle", "jno", "jnp", "jns", - "jnz", "jo", "jp", "jpe", "jpo", "js", "jz", "lahf", "lar", - "lds", "lea", "leave", "les", "lfence", "lfs", "lgdt", "lgs", "lidt", - "lldt", "lmsw", "lods", "lodsb", "lodsw", "lodsd", "lodsq", "loop", "loope", - "loopne", "loopnz", "loopz", "lsl", "lss", "ltr", "mov", "movs", "movbe", - "movsb", "movsw", "movsd", "movsq", "movsx", "movzx", "movsxd", "mul", "neg", - "nop", "not", "or", "out", "outs", "outsb", "outsw", "outsd", "pop", - "popa", "popaw", "popad", "popcnt", "popf", "popfw", "popfd", "popfq", "prefetchnta", - "prefetcht0", "prefetcht1", "prefetcht2", "push", "pusha", "pushaw", "pushad", "pushf", "pushfw", - "pushfd", "pushfq", "rcl", "rcr", "rdmsr", "rdpmc", "rdtsc", "ret", "retf", - "rol", "ror", "rsm", "sahf", "sal", "sar", "sbb", "scas", "scasb", - "scasw", "scasd", "scasq", "seta", "setae", "setb", "setbe", "setc", "sete", - "setg", "setge", "setl", "setle", "setna", "setnae", "setnb", "setnbe", "setnc", - "setne", "setng", "setnge", "setnl", "setnle", "setno", "setnp", "setns", "setnz", - "seto", "setp", "setpe", "setpo", "sets", "setz", "sfence", "sgdt", "shl", - "shld", "shr", "shrd", "sidt", "sldt", "smsw", "stc", "std", "sti", - "stos", "stosb", "stosw", "stosd", "stosq", "str", "sub", "syscall", "sysenter", - "sysexit", "sysret", "test", "ud2", "verr", "verw", "wait", "wbinvd", "wrmsr", - "xadd", "xchg", "xlat", "xlatb", "xor", "xrstor", "xrstor64", "xsave", "xsave64", - "xsetbv", "addpd", "addps", "addsd", "addss", "addsubpd", "addsubps", "andnpd", "andnps", - "andpd", "andps", "blendpd", "blendps", "cmppd", "cmpps", "comisd", "comiss", "cvtdq2pd", - "cvtdq2ps", "cvtpd2dq", "cvtpd2pi", "cvtpd2ps", "cvtpi2pd", "cvtpi2ps", "cvtps2dq", "cvtps2pd", "cvtps2pi", - "cvtsd2si", "cvtsd2ss", "cvtsi2sd", "cvtsi2ss", "cvtss2sd", "cvtss2si", "cvttpd2dq", "cvttpd2pi", "cvttps2dq", - "cvttps2pi", "cvttsd2si", "cvttss2si", "divpd", "divps", "divsd", "divss", "dppd", "dpps", - "hsubpd", "hsubps", "insertps", "lddqu", "maskmovdqu", "maskmovq", "maxpd", "maxps", "maxsd", - "maxss", "mfence", "pause", "minpd", "minps", "minsd", "minss", "monitor", "movapd", - "movaps", "movd", "movq", "movddup", "movdq2q", "movdqa", "movdqu", "movhlps", "movhpd", - "movhps", "movlhps", "movlpd", "movlps", "movmskpd", "movmskps", "movntdq", "movnti", "movntpd", - "movntd", "movntq", "movq2dq", "movshdup", "movsldup", "movss", "movupd", "movups", "mpsadbw", - "mulpd", "mulps", "mulsd", "mulss", "orpd", "orps", "packssdw", "packsswb", "packusdw", - "paddb", "paddd", "paddq", "paddsw", "paddusb", "paddusw", "paddw", "palignr", "pand", - "pandn", "pavgb", "pavgw", "pblendw", "pcmpeqb", "pcmpeqd", "pcmpeqw", "pcmpestri", "pcmpestrm", - "pcmpgtb", "pcmpgtd", "pcmpgtw", "pextrb", "pextrd", "pextrq", "pextrw", "pinsrb", "pinsrd", - "pinsrq", "pinsrw", "pmaddwd", "pmaxsw", "pmaxub", "pminsw", "pminub", "pmovmskb", "pmulhuw", - "pmulhw", "pmullw", "pmuludq", "psadbw", "pshufd", "pshufhw", "pshuflw", "pshufw", "pslld", - "pslldq", "psllq", "psllw", "psrad", "psraw", "psrld", "psrldq", "psrlq", "psrlw", - "psubb", "psubd", "psubq", "psubsb", "psubsw", "psubusb", "psubusw", "punpckhbw", "punpckhdq", - "punpckhqdq", "punpckhwd", "punpcklbw", "punpckldq", "punpcklqdq", "punpcklwd", "pxor", "rcpps", "rcpss", - "roundpd", "roundps", "roundsd", "roundss", "rsqrtps", "rsqrtss", "shufpd", "shufps", "sqrtpd", - "sqrtps", "sqrtsd", "sqrtss", "subpd", "subps", "subsd", "subss", "ucomisd", "ucomiss", - "unpckhpd", "unpckhps", "unpcklpd", "unpcklps", "xorpd", "xorps", "invept", "invvpid", "vmcall", - "vmclear", "vmlaunch", "vmptrld", "vmptrst", "vmread", "vmresume", "vmwrite", "vmxoff", "vmxon", - "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne", "repnz", - "repz", +const char * const opcodeTable[631] = { + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "aaa", + "aad", + "aam", + "aas", + "adc", + "add", + "and", + "arpl", + "bound", + "bsf", + "bsr", + "bswap", + "bt", + "btc", + "btr", + "bts", + "call", + "cbw", + "cdq", + "cdqe", + "clc", + "cld", + "cli", + "clts", + "cmc", + "cmova", + "cmovae", + "cmovb", + "cmovbe", + "cmovc", + "cmove", + "cmovg", + "cmovge", + "cmovl", + "cmovle", + "cmovna", + "cmovnae", + "cmovnb", + "cmovnbe", + "cmovnc", + "cmovne", + "cmovng", + "cmovnge", + "cmovnl", + "cmovnle", + "cmovno", + "cmovnp", + "cmovns", + "cmovnz", + "cmovo", + "cmovp", + "cmovpe", + "cmovpo", + "cmovs", + "cmovz", + "cmp", + "cmps", + "cmpsb", + "cmpsw", + "cmpsd", + "cmpsq", + "cmpxchg", + "cmpxchg8b", + "cmpxchg16b", + "cpuid", + "cqo", + "cwd", + "cwde", + "daa", + "das", + "dec", + "div", + "enter", + "esc", + "f2xm1", + "fabs", + "fadd", + "faddp", + "fbld", + "fbstp", + "fchs", + "fclex", + "fnclex", + "fcmovb", + "fcmovbe", + "fcmove", + "fcmovnb", + "fcmovnbe", + "fcmovne", + "fcmovnu", + "fcmovu", + "fcom", + "fcomi", + "fcomip", + "fcomp", + "fcompp", + "fcos", + "fdecstp", + "fdisi", + "fdiv", + "fdivp", + "fdivr", + "fdivrp", + "feni", + "ffree", + "ffreep", + "fiadd", + "ficom", + "ficomp", + "fidiv", + "fidivr", + "fild", + "fimul", + "fincstp", + "finit", + "fninit", + "fist", + "fistp", + "fisub", + "fisubr", + "fld", + "fld1", + "fldcw", + "fldenv", + "fldl2e", + "fldl2t", + "fldlg2", + "fldln2", + "fldpi", + "fldz", + "fmul", + "fmulp", + "fnop", + "fnsave", + "fpatan", + "fprem", + "fprem1", + "fptan", + "frndint", + "frstor", + "fsave", + "fscale", + "fsetpm", + "fsin", + "fsincos", + "fsqrt", + "fst", + "fstcw", + "fnstcw", + "fstenv", + "fnstenv", + "fstp", + "fstsw", + "fnstsw", + "fsub", + "fsubp", + "fsubr", + "fsubrp", + "ftst", + "fucom", + "fucomi", + "fucomip", + "fucomp", + "fucompp", + "fwait", + "fxam", + "fxch", + "fxch4", + "fxch7", + "fxrstor", + "fxsave", + "fxtract", + "fyl2x", + "fyl2xp1", + "hlt", + "icebp", + "idiv", + "imul", + "in", + "ins", + "insb", + "insw", + "insd", + "inc", + "int", + "int1", + "int3", + "into", + "invd", + "invlpg", + "iret", + "iretw", + "iretd", + "iretq", + "ja", + "jae", + "jb", + "jbe", + "jc", + "jcxz", + "jecxz", + "je", + "jg", + "jge", + "jl", + "jle", + "jmp", + "jna", + "jnae", + "jnb", + "jnbe", + "jnc", + "jne", + "jng", + "jnge", + "jnl", + "jnle", + "jno", + "jnp", + "jns", + "jnz", + "jo", + "jp", + "jpe", + "jpo", + "js", + "jz", + "lahf", + "lar", + "lds", + "lea", + "leave", + "les", + "lfence", + "lfs", + "lgdt", + "lgs", + "lidt", + "lldt", + "lmsw", + "lods", + "lodsb", + "lodsw", + "lodsd", + "lodsq", + "loop", + "loope", + "loopne", + "loopnz", + "loopz", + "lsl", + "lss", + "ltr", + "mov", + "movs", + "movbe", + "movsb", + "movsw", + "movsd", + "movsq", + "movsx", + "movzx", + "movsxd", + "mul", + "neg", + "nop", + "not", + "or", + "out", + "outs", + "outsb", + "outsw", + "outsd", + "pop", + "popa", + "popaw", + "popad", + "popcnt", + "popf", + "popfw", + "popfd", + "popfq", + "prefetchnta", + "prefetcht0", + "prefetcht1", + "prefetcht2", + "push", + "pusha", + "pushaw", + "pushad", + "pushf", + "pushfw", + "pushfd", + "pushfq", + "rcl", + "rcr", + "rdmsr", + "rdpmc", + "rdtsc", + "ret", + "retf", + "rol", + "ror", + "rsm", + "sahf", + "sal", + "sar", + "sbb", + "scas", + "scasb", + "scasw", + "scasd", + "scasq", + "seta", + "setae", + "setb", + "setbe", + "setc", + "sete", + "setg", + "setge", + "setl", + "setle", + "setna", + "setnae", + "setnb", + "setnbe", + "setnc", + "setne", + "setng", + "setnge", + "setnl", + "setnle", + "setno", + "setnp", + "setns", + "setnz", + "seto", + "setp", + "setpe", + "setpo", + "sets", + "setz", + "sfence", + "sgdt", + "shl", + "shld", + "shr", + "shrd", + "sidt", + "sldt", + "smsw", + "stc", + "std", + "sti", + "stos", + "stosb", + "stosw", + "stosd", + "stosq", + "str", + "sub", + "syscall", + "sysenter", + "sysexit", + "sysret", + "test", + "ud2", + "verr", + "verw", + "wait", + "wbinvd", + "wrmsr", + "xadd", + "xchg", + "xlat", + "xlatb", + "xor", + "xrstor", + "xrstor64", + "xsave", + "xsave64", + "xsetbv", + "addpd", + "addps", + "addsd", + "addss", + "addsubpd", + "addsubps", + "andnpd", + "andnps", + "andpd", + "andps", + "blendpd", + "blendps", + "cmppd", + "cmpps", + "comisd", + "comiss", + "cvtdq2pd", + "cvtdq2ps", + "cvtpd2dq", + "cvtpd2pi", + "cvtpd2ps", + "cvtpi2pd", + "cvtpi2ps", + "cvtps2dq", + "cvtps2pd", + "cvtps2pi", + "cvtsd2si", + "cvtsd2ss", + "cvtsi2sd", + "cvtsi2ss", + "cvtss2sd", + "cvtss2si", + "cvttpd2dq", + "cvttpd2pi", + "cvttps2dq", + "cvttps2pi", + "cvttsd2si", + "cvttss2si", + "divpd", + "divps", + "divsd", + "divss", + "dppd", + "dpps", + "hsubpd", + "hsubps", + "insertps", + "lddqu", + "maskmovdqu", + "maskmovq", + "maxpd", + "maxps", + "maxsd", + "maxss", + "mfence", + "pause", + "minpd", + "minps", + "minsd", + "minss", + "monitor", + "movapd", + "movaps", + "movd", + "movq", + "movddup", + "movdq2q", + "movdqa", + "movdqu", + "movhlps", + "movhpd", + "movhps", + "movlhps", + "movlpd", + "movlps", + "movmskpd", + "movmskps", + "movntdq", + "movnti", + "movntpd", + "movntd", + "movntq", + "movq2dq", + "movshdup", + "movsldup", + "movss", + "movupd", + "movups", + "mpsadbw", + "mulpd", + "mulps", + "mulsd", + "mulss", + "orpd", + "orps", + "packssdw", + "packsswb", + "packusdw", + "paddb", + "paddd", + "paddq", + "paddsw", + "paddusb", + "paddusw", + "paddw", + "palignr", + "pand", + "pandn", + "pavgb", + "pavgw", + "pblendw", + "pcmpeqb", + "pcmpeqd", + "pcmpeqw", + "pcmpestri", + "pcmpestrm", + "pcmpgtb", + "pcmpgtd", + "pcmpgtw", + "pextrb", + "pextrd", + "pextrq", + "pextrw", + "pinsrb", + "pinsrd", + "pinsrq", + "pinsrw", + "pmaddwd", + "pmaxsw", + "pmaxub", + "pminsw", + "pminub", + "pmovmskb", + "pmulhuw", + "pmulhw", + "pmullw", + "pmuludq", + "psadbw", + "pshufd", + "pshufhw", + "pshuflw", + "pshufw", + "pslld", + "pslldq", + "psllq", + "psllw", + "psrad", + "psraw", + "psrld", + "psrldq", + "psrlq", + "psrlw", + "psubb", + "psubd", + "psubq", + "psubsb", + "psubsw", + "psubusb", + "psubusw", + "punpckhbw", + "punpckhdq", + "punpckhqdq", + "punpckhwd", + "punpcklbw", + "punpckldq", + "punpcklqdq", + "punpcklwd", + "pxor", + "rcpps", + "rcpss", + "roundpd", + "roundps", + "roundsd", + "roundss", + "rsqrtps", + "rsqrtss", + "shufpd", + "shufps", + "sqrtpd", + "sqrtps", + "sqrtsd", + "sqrtss", + "subpd", + "subps", + "subsd", + "subss", + "ucomisd", + "ucomiss", + "unpckhpd", + "unpckhps", + "unpcklpd", + "unpcklps", + "xorpd", + "xorps", + "invept", + "invvpid", + "vmcall", + "vmclear", + "vmlaunch", + "vmptrld", + "vmptrst", + "vmread", + "vmresume", + "vmwrite", + "vmxoff", + "vmxon", + "a16", + "a32", + "lock", + "o16", + "o32", + "rep", + "repe", + "repne", + "repnz", + "repz", }; -std::unordered_map tokenNames = { - {tk_star, "*"}, {tk_plus, "+"}, {tk_comma, ","}, {tk_colon, ":"}, {tk_openbr, "["}, {tk_closebr, "]"}, - {tk_byte, "byte"}, {tk_dword, "dword"}, {tk_far, "far"}, {tk_near, "near"}, {tk_qword, "qword"}, {tk_short, "short"}, - {tk_tword, "tword"}, {tk_word, "word"}, {tk_al, "al"}, {tk_ah, "ah"}, {tk_ax, "ax"}, {tk_eax, "eax"}, - {tk_rax, "rax"}, {tk_r8b, "r8b"}, {tk_r8w, "r8w"}, {tk_r8d, "r8d"}, {tk_r8, "r8"}, {tk_cl, "cl"}, - {tk_ch, "ch"}, {tk_cx, "cx"}, {tk_ecx, "ecx"}, {tk_rcx, "rcx"}, {tk_r9b, "r9b"}, {tk_r9w, "r9w"}, - {tk_r9d, "r9d"}, {tk_r9, "r9"}, {tk_dl, "dl"}, {tk_dh, "dh"}, {tk_dx, "dx"}, {tk_edx, "edx"}, - {tk_rdx, "rdx"}, {tk_r10b, "r10b"}, {tk_r10w, "r10w"}, {tk_r10d, "r10d"}, {tk_r10, "r10"}, {tk_bl, "bl"}, - {tk_bh, "bh"}, {tk_bx, "bx"}, {tk_ebx, "ebx"}, {tk_rbx, "rbx"}, {tk_r11b, "r11b"}, {tk_r11w, "r11w"}, - {tk_r11d, "r11d"}, {tk_r11, "r11"}, {tk_spl, "spl"}, {tk_sp, "sp"}, {tk_esp, "esp"}, {tk_rsp, "rsp"}, - {tk_r12b, "r12b"}, {tk_r12w, "r12w"}, {tk_r12d, "r12d"}, {tk_r12, "r12"}, {tk_bpl, "bpl"}, {tk_bp, "bp"}, - {tk_ebp, "ebp"}, {tk_rbp, "rbp"}, {tk_r13b, "r13b"}, {tk_r13w, "r13w"}, {tk_r13d, "r13d"}, {tk_r13, "r13"}, - {tk_sil, "sil"}, {tk_si, "si"}, {tk_esi, "esi"}, {tk_rsi, "rsi"}, {tk_r14b, "r14b"}, {tk_r14w, "r14w"}, - {tk_r14d, "r14d"}, {tk_r14, "r14"}, {tk_dil, "dil"}, {tk_di, "di"}, {tk_edi, "edi"}, {tk_rdi, "rdi"}, - {tk_r15b, "r15b"}, {tk_r15w, "r15w"}, {tk_r15d, "r15d"}, {tk_r15, "r15"}, {tk_rip, "rip"}, {tk_mm0, "mm0"}, - {tk_xmm0, "xmm0"}, {tk_xmm8, "xmm8"}, {tk_mm1, "mm1"}, {tk_xmm1, "xmm1"}, {tk_xmm9, "xmm9"}, {tk_mm2, "mm2"}, - {tk_xmm2, "xmm2"}, {tk_xmm10, "xmm10"}, {tk_mm3, "mm3"}, {tk_xmm3, "xmm3"}, {tk_xmm11, "xmm11"}, {tk_mm4, "mm4"}, - {tk_xmm4, "xmm4"}, {tk_xmm12, "xmm12"}, {tk_mm5, "mm5"}, {tk_xmm5, "xmm5"}, {tk_xmm13, "xmm13"}, {tk_mm6, "mm6"}, - {tk_xmm6, "xmm6"}, {tk_xmm14, "xmm14"}, {tk_mm7, "mm7"}, {tk_xmm7, "xmm7"}, {tk_xmm15, "xmm15"}, {tk_es, "es"}, - {tk_cs, "cs"}, {tk_ss, "ss"}, {tk_ds, "ds"}, {tk_fs, "fs"}, {tk_gs, "gs"}, {tk_st0, "st0"}, - {tk_st1, "st1"}, {tk_st2, "st2"}, {tk_st3, "st3"}, {tk_st4, "st4"}, {tk_st5, "st5"}, {tk_st6, "st6"}, - {tk_st7, "st7"}, {tk_cr0, "cr0"}, {tk_cr1, "cr1"}, {tk_cr2, "cr2"}, {tk_cr3, "cr3"}, {tk_cr4, "cr4"}, - {tk_cr5, "cr5"}, {tk_cr6, "cr6"}, {tk_cr7, "cr7"}, {tk_dr0, "dr0"}, {tk_dr1, "dr1"}, {tk_dr2, "dr2"}, - {tk_dr3, "dr3"}, {tk_dr4, "dr4"}, {tk_dr5, "dr5"}, {tk_dr6, "dr6"}, {tk_dr7, "dr7"}, {tk_tr0, "tr0"}, - {tk_tr1, "tr1"}, {tk_tr2, "tr2"}, {tk_tr3, "tr3"}, {tk_tr4, "tr4"}, {tk_tr5, "tr5"}, {tk_tr6, "tr6"}, - {tk_tr7, "tr7"}, +std::unordered_map tokenNames = { + { tk_star, "*" }, + { tk_plus, "+" }, + { tk_comma, "," }, + { tk_colon, ":" }, + { tk_openbr, "[" }, + { tk_closebr, "]" }, + { tk_byte, "byte" }, + { tk_dword, "dword" }, + { tk_far, "far" }, + { tk_near, "near" }, + { tk_qword, "qword" }, + { tk_short, "short" }, + { tk_tword, "tword" }, + { tk_word, "word" }, + { tk_al, "al" }, + { tk_ah, "ah" }, + { tk_ax, "ax" }, + { tk_eax, "eax" }, + { tk_rax, "rax" }, + { tk_r8b, "r8b" }, + { tk_r8w, "r8w" }, + { tk_r8d, "r8d" }, + { tk_r8, "r8" }, + { tk_cl, "cl" }, + { tk_ch, "ch" }, + { tk_cx, "cx" }, + { tk_ecx, "ecx" }, + { tk_rcx, "rcx" }, + { tk_r9b, "r9b" }, + { tk_r9w, "r9w" }, + { tk_r9d, "r9d" }, + { tk_r9, "r9" }, + { tk_dl, "dl" }, + { tk_dh, "dh" }, + { tk_dx, "dx" }, + { tk_edx, "edx" }, + { tk_rdx, "rdx" }, + { tk_r10b, "r10b" }, + { tk_r10w, "r10w" }, + { tk_r10d, "r10d" }, + { tk_r10, "r10" }, + { tk_bl, "bl" }, + { tk_bh, "bh" }, + { tk_bx, "bx" }, + { tk_ebx, "ebx" }, + { tk_rbx, "rbx" }, + { tk_r11b, "r11b" }, + { tk_r11w, "r11w" }, + { tk_r11d, "r11d" }, + { tk_r11, "r11" }, + { tk_spl, "spl" }, + { tk_sp, "sp" }, + { tk_esp, "esp" }, + { tk_rsp, "rsp" }, + { tk_r12b, "r12b" }, + { tk_r12w, "r12w" }, + { tk_r12d, "r12d" }, + { tk_r12, "r12" }, + { tk_bpl, "bpl" }, + { tk_bp, "bp" }, + { tk_ebp, "ebp" }, + { tk_rbp, "rbp" }, + { tk_r13b, "r13b" }, + { tk_r13w, "r13w" }, + { tk_r13d, "r13d" }, + { tk_r13, "r13" }, + { tk_sil, "sil" }, + { tk_si, "si" }, + { tk_esi, "esi" }, + { tk_rsi, "rsi" }, + { tk_r14b, "r14b" }, + { tk_r14w, "r14w" }, + { tk_r14d, "r14d" }, + { tk_r14, "r14" }, + { tk_dil, "dil" }, + { tk_di, "di" }, + { tk_edi, "edi" }, + { tk_rdi, "rdi" }, + { tk_r15b, "r15b" }, + { tk_r15w, "r15w" }, + { tk_r15d, "r15d" }, + { tk_r15, "r15" }, + { tk_rip, "rip" }, + { tk_mm0, "mm0" }, + { tk_xmm0, "xmm0" }, + { tk_xmm8, "xmm8" }, + { tk_mm1, "mm1" }, + { tk_xmm1, "xmm1" }, + { tk_xmm9, "xmm9" }, + { tk_mm2, "mm2" }, + { tk_xmm2, "xmm2" }, + { tk_xmm10, "xmm10" }, + { tk_mm3, "mm3" }, + { tk_xmm3, "xmm3" }, + { tk_xmm11, "xmm11" }, + { tk_mm4, "mm4" }, + { tk_xmm4, "xmm4" }, + { tk_xmm12, "xmm12" }, + { tk_mm5, "mm5" }, + { tk_xmm5, "xmm5" }, + { tk_xmm13, "xmm13" }, + { tk_mm6, "mm6" }, + { tk_xmm6, "xmm6" }, + { tk_xmm14, "xmm14" }, + { tk_mm7, "mm7" }, + { tk_xmm7, "xmm7" }, + { tk_xmm15, "xmm15" }, + { tk_es, "es" }, + { tk_cs, "cs" }, + { tk_ss, "ss" }, + { tk_ds, "ds" }, + { tk_fs, "fs" }, + { tk_gs, "gs" }, + { tk_st0, "st0" }, + { tk_st1, "st1" }, + { tk_st2, "st2" }, + { tk_st3, "st3" }, + { tk_st4, "st4" }, + { tk_st5, "st5" }, + { tk_st6, "st6" }, + { tk_st7, "st7" }, + { tk_cr0, "cr0" }, + { tk_cr1, "cr1" }, + { tk_cr2, "cr2" }, + { tk_cr3, "cr3" }, + { tk_cr4, "cr4" }, + { tk_cr5, "cr5" }, + { tk_cr6, "cr6" }, + { tk_cr7, "cr7" }, + { tk_dr0, "dr0" }, + { tk_dr1, "dr1" }, + { tk_dr2, "dr2" }, + { tk_dr3, "dr3" }, + { tk_dr4, "dr4" }, + { tk_dr5, "dr5" }, + { tk_dr6, "dr6" }, + { tk_dr7, "dr7" }, + { tk_tr0, "tr0" }, + { tk_tr1, "tr1" }, + { tk_tr2, "tr2" }, + { tk_tr3, "tr3" }, + { tk_tr4, "tr4" }, + { tk_tr5, "tr5" }, + { tk_tr6, "tr6" }, + { tk_tr7, "tr7" }, }; -InputToken Tokenstar{InputToken::TOKEN, new AdlExprNode(tk_star)}; -InputToken Tokenplus{InputToken::TOKEN, new AdlExprNode(tk_plus)}; -InputToken Tokencomma{InputToken::TOKEN, new AdlExprNode(tk_comma)}; -InputToken Tokencolon{InputToken::TOKEN, new AdlExprNode(tk_colon)}; -InputToken Tokenopenbr{InputToken::TOKEN, new AdlExprNode(tk_openbr)}; -InputToken Tokenclosebr{InputToken::TOKEN, new AdlExprNode(tk_closebr)}; -InputToken Tokenbyte{InputToken::TOKEN, new AdlExprNode(tk_byte)}; -InputToken Tokendword{InputToken::TOKEN, new AdlExprNode(tk_dword)}; -InputToken Tokenfar{InputToken::TOKEN, new AdlExprNode(tk_far)}; -InputToken Tokennear{InputToken::TOKEN, new AdlExprNode(tk_near)}; -InputToken Tokenqword{InputToken::TOKEN, new AdlExprNode(tk_qword)}; -InputToken Tokenshort{InputToken::TOKEN, new AdlExprNode(tk_short)}; -InputToken Tokentword{InputToken::TOKEN, new AdlExprNode(tk_tword)}; -InputToken Tokenword{InputToken::TOKEN, new AdlExprNode(tk_word)}; -InputToken Tokenal{InputToken::REGISTER, new AdlExprNode(tk_al - 1000)}; -InputToken Tokenah{InputToken::REGISTER, new AdlExprNode(tk_ah - 1000)}; -InputToken Tokenax{InputToken::REGISTER, new AdlExprNode(tk_ax - 1000)}; -InputToken Tokeneax{InputToken::REGISTER, new AdlExprNode(tk_eax - 1000)}; -InputToken Tokenrax{InputToken::REGISTER, new AdlExprNode(tk_rax - 1000)}; -InputToken Tokenr8b{InputToken::REGISTER, new AdlExprNode(tk_r8b - 1000)}; -InputToken Tokenr8w{InputToken::REGISTER, new AdlExprNode(tk_r8w - 1000)}; -InputToken Tokenr8d{InputToken::REGISTER, new AdlExprNode(tk_r8d - 1000)}; -InputToken Tokenr8{InputToken::REGISTER, new AdlExprNode(tk_r8 - 1000)}; -InputToken Tokencl{InputToken::REGISTER, new AdlExprNode(tk_cl - 1000)}; -InputToken Tokench{InputToken::REGISTER, new AdlExprNode(tk_ch - 1000)}; -InputToken Tokencx{InputToken::REGISTER, new AdlExprNode(tk_cx - 1000)}; -InputToken Tokenecx{InputToken::REGISTER, new AdlExprNode(tk_ecx - 1000)}; -InputToken Tokenrcx{InputToken::REGISTER, new AdlExprNode(tk_rcx - 1000)}; -InputToken Tokenr9b{InputToken::REGISTER, new AdlExprNode(tk_r9b - 1000)}; -InputToken Tokenr9w{InputToken::REGISTER, new AdlExprNode(tk_r9w - 1000)}; -InputToken Tokenr9d{InputToken::REGISTER, new AdlExprNode(tk_r9d - 1000)}; -InputToken Tokenr9{InputToken::REGISTER, new AdlExprNode(tk_r9 - 1000)}; -InputToken Tokendl{InputToken::REGISTER, new AdlExprNode(tk_dl - 1000)}; -InputToken Tokendh{InputToken::REGISTER, new AdlExprNode(tk_dh - 1000)}; -InputToken Tokendx{InputToken::REGISTER, new AdlExprNode(tk_dx - 1000)}; -InputToken Tokenedx{InputToken::REGISTER, new AdlExprNode(tk_edx - 1000)}; -InputToken Tokenrdx{InputToken::REGISTER, new AdlExprNode(tk_rdx - 1000)}; -InputToken Tokenr10b{InputToken::REGISTER, new AdlExprNode(tk_r10b - 1000)}; -InputToken Tokenr10w{InputToken::REGISTER, new AdlExprNode(tk_r10w - 1000)}; -InputToken Tokenr10d{InputToken::REGISTER, new AdlExprNode(tk_r10d - 1000)}; -InputToken Tokenr10{InputToken::REGISTER, new AdlExprNode(tk_r10 - 1000)}; -InputToken Tokenbl{InputToken::REGISTER, new AdlExprNode(tk_bl - 1000)}; -InputToken Tokenbh{InputToken::REGISTER, new AdlExprNode(tk_bh - 1000)}; -InputToken Tokenbx{InputToken::REGISTER, new AdlExprNode(tk_bx - 1000)}; -InputToken Tokenebx{InputToken::REGISTER, new AdlExprNode(tk_ebx - 1000)}; -InputToken Tokenrbx{InputToken::REGISTER, new AdlExprNode(tk_rbx - 1000)}; -InputToken Tokenr11b{InputToken::REGISTER, new AdlExprNode(tk_r11b - 1000)}; -InputToken Tokenr11w{InputToken::REGISTER, new AdlExprNode(tk_r11w - 1000)}; -InputToken Tokenr11d{InputToken::REGISTER, new AdlExprNode(tk_r11d - 1000)}; -InputToken Tokenr11{InputToken::REGISTER, new AdlExprNode(tk_r11 - 1000)}; -InputToken Tokenspl{InputToken::REGISTER, new AdlExprNode(tk_spl - 1000)}; -InputToken Tokensp{InputToken::REGISTER, new AdlExprNode(tk_sp - 1000)}; -InputToken Tokenesp{InputToken::REGISTER, new AdlExprNode(tk_esp - 1000)}; -InputToken Tokenrsp{InputToken::REGISTER, new AdlExprNode(tk_rsp - 1000)}; -InputToken Tokenr12b{InputToken::REGISTER, new AdlExprNode(tk_r12b - 1000)}; -InputToken Tokenr12w{InputToken::REGISTER, new AdlExprNode(tk_r12w - 1000)}; -InputToken Tokenr12d{InputToken::REGISTER, new AdlExprNode(tk_r12d - 1000)}; -InputToken Tokenr12{InputToken::REGISTER, new AdlExprNode(tk_r12 - 1000)}; -InputToken Tokenbpl{InputToken::REGISTER, new AdlExprNode(tk_bpl - 1000)}; -InputToken Tokenbp{InputToken::REGISTER, new AdlExprNode(tk_bp - 1000)}; -InputToken Tokenebp{InputToken::REGISTER, new AdlExprNode(tk_ebp - 1000)}; -InputToken Tokenrbp{InputToken::REGISTER, new AdlExprNode(tk_rbp - 1000)}; -InputToken Tokenr13b{InputToken::REGISTER, new AdlExprNode(tk_r13b - 1000)}; -InputToken Tokenr13w{InputToken::REGISTER, new AdlExprNode(tk_r13w - 1000)}; -InputToken Tokenr13d{InputToken::REGISTER, new AdlExprNode(tk_r13d - 1000)}; -InputToken Tokenr13{InputToken::REGISTER, new AdlExprNode(tk_r13 - 1000)}; -InputToken Tokensil{InputToken::REGISTER, new AdlExprNode(tk_sil - 1000)}; -InputToken Tokensi{InputToken::REGISTER, new AdlExprNode(tk_si - 1000)}; -InputToken Tokenesi{InputToken::REGISTER, new AdlExprNode(tk_esi - 1000)}; -InputToken Tokenrsi{InputToken::REGISTER, new AdlExprNode(tk_rsi - 1000)}; -InputToken Tokenr14b{InputToken::REGISTER, new AdlExprNode(tk_r14b - 1000)}; -InputToken Tokenr14w{InputToken::REGISTER, new AdlExprNode(tk_r14w - 1000)}; -InputToken Tokenr14d{InputToken::REGISTER, new AdlExprNode(tk_r14d - 1000)}; -InputToken Tokenr14{InputToken::REGISTER, new AdlExprNode(tk_r14 - 1000)}; -InputToken Tokendil{InputToken::REGISTER, new AdlExprNode(tk_dil - 1000)}; -InputToken Tokendi{InputToken::REGISTER, new AdlExprNode(tk_di - 1000)}; -InputToken Tokenedi{InputToken::REGISTER, new AdlExprNode(tk_edi - 1000)}; -InputToken Tokenrdi{InputToken::REGISTER, new AdlExprNode(tk_rdi - 1000)}; -InputToken Tokenr15b{InputToken::REGISTER, new AdlExprNode(tk_r15b - 1000)}; -InputToken Tokenr15w{InputToken::REGISTER, new AdlExprNode(tk_r15w - 1000)}; -InputToken Tokenr15d{InputToken::REGISTER, new AdlExprNode(tk_r15d - 1000)}; -InputToken Tokenr15{InputToken::REGISTER, new AdlExprNode(tk_r15 - 1000)}; -InputToken Tokenrip{InputToken::REGISTER, new AdlExprNode(tk_rip - 1000)}; -InputToken Tokenmm0{InputToken::REGISTER, new AdlExprNode(tk_mm0 - 1000)}; -InputToken Tokenxmm0{InputToken::REGISTER, new AdlExprNode(tk_xmm0 - 1000)}; -InputToken Tokenxmm8{InputToken::REGISTER, new AdlExprNode(tk_xmm8 - 1000)}; -InputToken Tokenmm1{InputToken::REGISTER, new AdlExprNode(tk_mm1 - 1000)}; -InputToken Tokenxmm1{InputToken::REGISTER, new AdlExprNode(tk_xmm1 - 1000)}; -InputToken Tokenxmm9{InputToken::REGISTER, new AdlExprNode(tk_xmm9 - 1000)}; -InputToken Tokenmm2{InputToken::REGISTER, new AdlExprNode(tk_mm2 - 1000)}; -InputToken Tokenxmm2{InputToken::REGISTER, new AdlExprNode(tk_xmm2 - 1000)}; -InputToken Tokenxmm10{InputToken::REGISTER, new AdlExprNode(tk_xmm10 - 1000)}; -InputToken Tokenmm3{InputToken::REGISTER, new AdlExprNode(tk_mm3 - 1000)}; -InputToken Tokenxmm3{InputToken::REGISTER, new AdlExprNode(tk_xmm3 - 1000)}; -InputToken Tokenxmm11{InputToken::REGISTER, new AdlExprNode(tk_xmm11 - 1000)}; -InputToken Tokenmm4{InputToken::REGISTER, new AdlExprNode(tk_mm4 - 1000)}; -InputToken Tokenxmm4{InputToken::REGISTER, new AdlExprNode(tk_xmm4 - 1000)}; -InputToken Tokenxmm12{InputToken::REGISTER, new AdlExprNode(tk_xmm12 - 1000)}; -InputToken Tokenmm5{InputToken::REGISTER, new AdlExprNode(tk_mm5 - 1000)}; -InputToken Tokenxmm5{InputToken::REGISTER, new AdlExprNode(tk_xmm5 - 1000)}; -InputToken Tokenxmm13{InputToken::REGISTER, new AdlExprNode(tk_xmm13 - 1000)}; -InputToken Tokenmm6{InputToken::REGISTER, new AdlExprNode(tk_mm6 - 1000)}; -InputToken Tokenxmm6{InputToken::REGISTER, new AdlExprNode(tk_xmm6 - 1000)}; -InputToken Tokenxmm14{InputToken::REGISTER, new AdlExprNode(tk_xmm14 - 1000)}; -InputToken Tokenmm7{InputToken::REGISTER, new AdlExprNode(tk_mm7 - 1000)}; -InputToken Tokenxmm7{InputToken::REGISTER, new AdlExprNode(tk_xmm7 - 1000)}; -InputToken Tokenxmm15{InputToken::REGISTER, new AdlExprNode(tk_xmm15 - 1000)}; -InputToken Tokenes{InputToken::REGISTER, new AdlExprNode(tk_es - 1000)}; -InputToken Tokencs{InputToken::REGISTER, new AdlExprNode(tk_cs - 1000)}; -InputToken Tokenss{InputToken::REGISTER, new AdlExprNode(tk_ss - 1000)}; -InputToken Tokends{InputToken::REGISTER, new AdlExprNode(tk_ds - 1000)}; -InputToken Tokenfs{InputToken::REGISTER, new AdlExprNode(tk_fs - 1000)}; -InputToken Tokengs{InputToken::REGISTER, new AdlExprNode(tk_gs - 1000)}; -InputToken Tokenst0{InputToken::REGISTER, new AdlExprNode(tk_st0 - 1000)}; -InputToken Tokenst1{InputToken::REGISTER, new AdlExprNode(tk_st1 - 1000)}; -InputToken Tokenst2{InputToken::REGISTER, new AdlExprNode(tk_st2 - 1000)}; -InputToken Tokenst3{InputToken::REGISTER, new AdlExprNode(tk_st3 - 1000)}; -InputToken Tokenst4{InputToken::REGISTER, new AdlExprNode(tk_st4 - 1000)}; -InputToken Tokenst5{InputToken::REGISTER, new AdlExprNode(tk_st5 - 1000)}; -InputToken Tokenst6{InputToken::REGISTER, new AdlExprNode(tk_st6 - 1000)}; -InputToken Tokenst7{InputToken::REGISTER, new AdlExprNode(tk_st7 - 1000)}; -InputToken Tokencr0{InputToken::REGISTER, new AdlExprNode(tk_cr0 - 1000)}; -InputToken Tokencr1{InputToken::REGISTER, new AdlExprNode(tk_cr1 - 1000)}; -InputToken Tokencr2{InputToken::REGISTER, new AdlExprNode(tk_cr2 - 1000)}; -InputToken Tokencr3{InputToken::REGISTER, new AdlExprNode(tk_cr3 - 1000)}; -InputToken Tokencr4{InputToken::REGISTER, new AdlExprNode(tk_cr4 - 1000)}; -InputToken Tokencr5{InputToken::REGISTER, new AdlExprNode(tk_cr5 - 1000)}; -InputToken Tokencr6{InputToken::REGISTER, new AdlExprNode(tk_cr6 - 1000)}; -InputToken Tokencr7{InputToken::REGISTER, new AdlExprNode(tk_cr7 - 1000)}; -InputToken Tokendr0{InputToken::REGISTER, new AdlExprNode(tk_dr0 - 1000)}; -InputToken Tokendr1{InputToken::REGISTER, new AdlExprNode(tk_dr1 - 1000)}; -InputToken Tokendr2{InputToken::REGISTER, new AdlExprNode(tk_dr2 - 1000)}; -InputToken Tokendr3{InputToken::REGISTER, new AdlExprNode(tk_dr3 - 1000)}; -InputToken Tokendr4{InputToken::REGISTER, new AdlExprNode(tk_dr4 - 1000)}; -InputToken Tokendr5{InputToken::REGISTER, new AdlExprNode(tk_dr5 - 1000)}; -InputToken Tokendr6{InputToken::REGISTER, new AdlExprNode(tk_dr6 - 1000)}; -InputToken Tokendr7{InputToken::REGISTER, new AdlExprNode(tk_dr7 - 1000)}; -InputToken Tokentr0{InputToken::REGISTER, new AdlExprNode(tk_tr0 - 1000)}; -InputToken Tokentr1{InputToken::REGISTER, new AdlExprNode(tk_tr1 - 1000)}; -InputToken Tokentr2{InputToken::REGISTER, new AdlExprNode(tk_tr2 - 1000)}; -InputToken Tokentr3{InputToken::REGISTER, new AdlExprNode(tk_tr3 - 1000)}; -InputToken Tokentr4{InputToken::REGISTER, new AdlExprNode(tk_tr4 - 1000)}; -InputToken Tokentr5{InputToken::REGISTER, new AdlExprNode(tk_tr5 - 1000)}; -InputToken Tokentr6{InputToken::REGISTER, new AdlExprNode(tk_tr6 - 1000)}; -InputToken Tokentr7{InputToken::REGISTER, new AdlExprNode(tk_tr7 - 1000)}; +InputToken Tokenstar{ InputToken::TOKEN, new AdlExprNode(tk_star) }; +InputToken Tokenplus{ InputToken::TOKEN, new AdlExprNode(tk_plus) }; +InputToken Tokencomma{ InputToken::TOKEN, new AdlExprNode(tk_comma) }; +InputToken Tokencolon{ InputToken::TOKEN, new AdlExprNode(tk_colon) }; +InputToken Tokenopenbr{ InputToken::TOKEN, new AdlExprNode(tk_openbr) }; +InputToken Tokenclosebr{ InputToken::TOKEN, new AdlExprNode(tk_closebr) }; +InputToken Tokenbyte{ InputToken::TOKEN, new AdlExprNode(tk_byte) }; +InputToken Tokendword{ InputToken::TOKEN, new AdlExprNode(tk_dword) }; +InputToken Tokenfar{ InputToken::TOKEN, new AdlExprNode(tk_far) }; +InputToken Tokennear{ InputToken::TOKEN, new AdlExprNode(tk_near) }; +InputToken Tokenqword{ InputToken::TOKEN, new AdlExprNode(tk_qword) }; +InputToken Tokenshort{ InputToken::TOKEN, new AdlExprNode(tk_short) }; +InputToken Tokentword{ InputToken::TOKEN, new AdlExprNode(tk_tword) }; +InputToken Tokenword{ InputToken::TOKEN, new AdlExprNode(tk_word) }; +InputToken Tokenal{ InputToken::REGISTER, new AdlExprNode(tk_al - 1000) }; +InputToken Tokenah{ InputToken::REGISTER, new AdlExprNode(tk_ah - 1000) }; +InputToken Tokenax{ InputToken::REGISTER, new AdlExprNode(tk_ax - 1000) }; +InputToken Tokeneax{ InputToken::REGISTER, new AdlExprNode(tk_eax - 1000) }; +InputToken Tokenrax{ InputToken::REGISTER, new AdlExprNode(tk_rax - 1000) }; +InputToken Tokenr8b{ InputToken::REGISTER, new AdlExprNode(tk_r8b - 1000) }; +InputToken Tokenr8w{ InputToken::REGISTER, new AdlExprNode(tk_r8w - 1000) }; +InputToken Tokenr8d{ InputToken::REGISTER, new AdlExprNode(tk_r8d - 1000) }; +InputToken Tokenr8{ InputToken::REGISTER, new AdlExprNode(tk_r8 - 1000) }; +InputToken Tokencl{ InputToken::REGISTER, new AdlExprNode(tk_cl - 1000) }; +InputToken Tokench{ InputToken::REGISTER, new AdlExprNode(tk_ch - 1000) }; +InputToken Tokencx{ InputToken::REGISTER, new AdlExprNode(tk_cx - 1000) }; +InputToken Tokenecx{ InputToken::REGISTER, new AdlExprNode(tk_ecx - 1000) }; +InputToken Tokenrcx{ InputToken::REGISTER, new AdlExprNode(tk_rcx - 1000) }; +InputToken Tokenr9b{ InputToken::REGISTER, new AdlExprNode(tk_r9b - 1000) }; +InputToken Tokenr9w{ InputToken::REGISTER, new AdlExprNode(tk_r9w - 1000) }; +InputToken Tokenr9d{ InputToken::REGISTER, new AdlExprNode(tk_r9d - 1000) }; +InputToken Tokenr9{ InputToken::REGISTER, new AdlExprNode(tk_r9 - 1000) }; +InputToken Tokendl{ InputToken::REGISTER, new AdlExprNode(tk_dl - 1000) }; +InputToken Tokendh{ InputToken::REGISTER, new AdlExprNode(tk_dh - 1000) }; +InputToken Tokendx{ InputToken::REGISTER, new AdlExprNode(tk_dx - 1000) }; +InputToken Tokenedx{ InputToken::REGISTER, new AdlExprNode(tk_edx - 1000) }; +InputToken Tokenrdx{ InputToken::REGISTER, new AdlExprNode(tk_rdx - 1000) }; +InputToken Tokenr10b{ InputToken::REGISTER, new AdlExprNode(tk_r10b - 1000) }; +InputToken Tokenr10w{ InputToken::REGISTER, new AdlExprNode(tk_r10w - 1000) }; +InputToken Tokenr10d{ InputToken::REGISTER, new AdlExprNode(tk_r10d - 1000) }; +InputToken Tokenr10{ InputToken::REGISTER, new AdlExprNode(tk_r10 - 1000) }; +InputToken Tokenbl{ InputToken::REGISTER, new AdlExprNode(tk_bl - 1000) }; +InputToken Tokenbh{ InputToken::REGISTER, new AdlExprNode(tk_bh - 1000) }; +InputToken Tokenbx{ InputToken::REGISTER, new AdlExprNode(tk_bx - 1000) }; +InputToken Tokenebx{ InputToken::REGISTER, new AdlExprNode(tk_ebx - 1000) }; +InputToken Tokenrbx{ InputToken::REGISTER, new AdlExprNode(tk_rbx - 1000) }; +InputToken Tokenr11b{ InputToken::REGISTER, new AdlExprNode(tk_r11b - 1000) }; +InputToken Tokenr11w{ InputToken::REGISTER, new AdlExprNode(tk_r11w - 1000) }; +InputToken Tokenr11d{ InputToken::REGISTER, new AdlExprNode(tk_r11d - 1000) }; +InputToken Tokenr11{ InputToken::REGISTER, new AdlExprNode(tk_r11 - 1000) }; +InputToken Tokenspl{ InputToken::REGISTER, new AdlExprNode(tk_spl - 1000) }; +InputToken Tokensp{ InputToken::REGISTER, new AdlExprNode(tk_sp - 1000) }; +InputToken Tokenesp{ InputToken::REGISTER, new AdlExprNode(tk_esp - 1000) }; +InputToken Tokenrsp{ InputToken::REGISTER, new AdlExprNode(tk_rsp - 1000) }; +InputToken Tokenr12b{ InputToken::REGISTER, new AdlExprNode(tk_r12b - 1000) }; +InputToken Tokenr12w{ InputToken::REGISTER, new AdlExprNode(tk_r12w - 1000) }; +InputToken Tokenr12d{ InputToken::REGISTER, new AdlExprNode(tk_r12d - 1000) }; +InputToken Tokenr12{ InputToken::REGISTER, new AdlExprNode(tk_r12 - 1000) }; +InputToken Tokenbpl{ InputToken::REGISTER, new AdlExprNode(tk_bpl - 1000) }; +InputToken Tokenbp{ InputToken::REGISTER, new AdlExprNode(tk_bp - 1000) }; +InputToken Tokenebp{ InputToken::REGISTER, new AdlExprNode(tk_ebp - 1000) }; +InputToken Tokenrbp{ InputToken::REGISTER, new AdlExprNode(tk_rbp - 1000) }; +InputToken Tokenr13b{ InputToken::REGISTER, new AdlExprNode(tk_r13b - 1000) }; +InputToken Tokenr13w{ InputToken::REGISTER, new AdlExprNode(tk_r13w - 1000) }; +InputToken Tokenr13d{ InputToken::REGISTER, new AdlExprNode(tk_r13d - 1000) }; +InputToken Tokenr13{ InputToken::REGISTER, new AdlExprNode(tk_r13 - 1000) }; +InputToken Tokensil{ InputToken::REGISTER, new AdlExprNode(tk_sil - 1000) }; +InputToken Tokensi{ InputToken::REGISTER, new AdlExprNode(tk_si - 1000) }; +InputToken Tokenesi{ InputToken::REGISTER, new AdlExprNode(tk_esi - 1000) }; +InputToken Tokenrsi{ InputToken::REGISTER, new AdlExprNode(tk_rsi - 1000) }; +InputToken Tokenr14b{ InputToken::REGISTER, new AdlExprNode(tk_r14b - 1000) }; +InputToken Tokenr14w{ InputToken::REGISTER, new AdlExprNode(tk_r14w - 1000) }; +InputToken Tokenr14d{ InputToken::REGISTER, new AdlExprNode(tk_r14d - 1000) }; +InputToken Tokenr14{ InputToken::REGISTER, new AdlExprNode(tk_r14 - 1000) }; +InputToken Tokendil{ InputToken::REGISTER, new AdlExprNode(tk_dil - 1000) }; +InputToken Tokendi{ InputToken::REGISTER, new AdlExprNode(tk_di - 1000) }; +InputToken Tokenedi{ InputToken::REGISTER, new AdlExprNode(tk_edi - 1000) }; +InputToken Tokenrdi{ InputToken::REGISTER, new AdlExprNode(tk_rdi - 1000) }; +InputToken Tokenr15b{ InputToken::REGISTER, new AdlExprNode(tk_r15b - 1000) }; +InputToken Tokenr15w{ InputToken::REGISTER, new AdlExprNode(tk_r15w - 1000) }; +InputToken Tokenr15d{ InputToken::REGISTER, new AdlExprNode(tk_r15d - 1000) }; +InputToken Tokenr15{ InputToken::REGISTER, new AdlExprNode(tk_r15 - 1000) }; +InputToken Tokenrip{ InputToken::REGISTER, new AdlExprNode(tk_rip - 1000) }; +InputToken Tokenmm0{ InputToken::REGISTER, new AdlExprNode(tk_mm0 - 1000) }; +InputToken Tokenxmm0{ InputToken::REGISTER, new AdlExprNode(tk_xmm0 - 1000) }; +InputToken Tokenxmm8{ InputToken::REGISTER, new AdlExprNode(tk_xmm8 - 1000) }; +InputToken Tokenmm1{ InputToken::REGISTER, new AdlExprNode(tk_mm1 - 1000) }; +InputToken Tokenxmm1{ InputToken::REGISTER, new AdlExprNode(tk_xmm1 - 1000) }; +InputToken Tokenxmm9{ InputToken::REGISTER, new AdlExprNode(tk_xmm9 - 1000) }; +InputToken Tokenmm2{ InputToken::REGISTER, new AdlExprNode(tk_mm2 - 1000) }; +InputToken Tokenxmm2{ InputToken::REGISTER, new AdlExprNode(tk_xmm2 - 1000) }; +InputToken Tokenxmm10{ InputToken::REGISTER, new AdlExprNode(tk_xmm10 - 1000) }; +InputToken Tokenmm3{ InputToken::REGISTER, new AdlExprNode(tk_mm3 - 1000) }; +InputToken Tokenxmm3{ InputToken::REGISTER, new AdlExprNode(tk_xmm3 - 1000) }; +InputToken Tokenxmm11{ InputToken::REGISTER, new AdlExprNode(tk_xmm11 - 1000) }; +InputToken Tokenmm4{ InputToken::REGISTER, new AdlExprNode(tk_mm4 - 1000) }; +InputToken Tokenxmm4{ InputToken::REGISTER, new AdlExprNode(tk_xmm4 - 1000) }; +InputToken Tokenxmm12{ InputToken::REGISTER, new AdlExprNode(tk_xmm12 - 1000) }; +InputToken Tokenmm5{ InputToken::REGISTER, new AdlExprNode(tk_mm5 - 1000) }; +InputToken Tokenxmm5{ InputToken::REGISTER, new AdlExprNode(tk_xmm5 - 1000) }; +InputToken Tokenxmm13{ InputToken::REGISTER, new AdlExprNode(tk_xmm13 - 1000) }; +InputToken Tokenmm6{ InputToken::REGISTER, new AdlExprNode(tk_mm6 - 1000) }; +InputToken Tokenxmm6{ InputToken::REGISTER, new AdlExprNode(tk_xmm6 - 1000) }; +InputToken Tokenxmm14{ InputToken::REGISTER, new AdlExprNode(tk_xmm14 - 1000) }; +InputToken Tokenmm7{ InputToken::REGISTER, new AdlExprNode(tk_mm7 - 1000) }; +InputToken Tokenxmm7{ InputToken::REGISTER, new AdlExprNode(tk_xmm7 - 1000) }; +InputToken Tokenxmm15{ InputToken::REGISTER, new AdlExprNode(tk_xmm15 - 1000) }; +InputToken Tokenes{ InputToken::REGISTER, new AdlExprNode(tk_es - 1000) }; +InputToken Tokencs{ InputToken::REGISTER, new AdlExprNode(tk_cs - 1000) }; +InputToken Tokenss{ InputToken::REGISTER, new AdlExprNode(tk_ss - 1000) }; +InputToken Tokends{ InputToken::REGISTER, new AdlExprNode(tk_ds - 1000) }; +InputToken Tokenfs{ InputToken::REGISTER, new AdlExprNode(tk_fs - 1000) }; +InputToken Tokengs{ InputToken::REGISTER, new AdlExprNode(tk_gs - 1000) }; +InputToken Tokenst0{ InputToken::REGISTER, new AdlExprNode(tk_st0 - 1000) }; +InputToken Tokenst1{ InputToken::REGISTER, new AdlExprNode(tk_st1 - 1000) }; +InputToken Tokenst2{ InputToken::REGISTER, new AdlExprNode(tk_st2 - 1000) }; +InputToken Tokenst3{ InputToken::REGISTER, new AdlExprNode(tk_st3 - 1000) }; +InputToken Tokenst4{ InputToken::REGISTER, new AdlExprNode(tk_st4 - 1000) }; +InputToken Tokenst5{ InputToken::REGISTER, new AdlExprNode(tk_st5 - 1000) }; +InputToken Tokenst6{ InputToken::REGISTER, new AdlExprNode(tk_st6 - 1000) }; +InputToken Tokenst7{ InputToken::REGISTER, new AdlExprNode(tk_st7 - 1000) }; +InputToken Tokencr0{ InputToken::REGISTER, new AdlExprNode(tk_cr0 - 1000) }; +InputToken Tokencr1{ InputToken::REGISTER, new AdlExprNode(tk_cr1 - 1000) }; +InputToken Tokencr2{ InputToken::REGISTER, new AdlExprNode(tk_cr2 - 1000) }; +InputToken Tokencr3{ InputToken::REGISTER, new AdlExprNode(tk_cr3 - 1000) }; +InputToken Tokencr4{ InputToken::REGISTER, new AdlExprNode(tk_cr4 - 1000) }; +InputToken Tokencr5{ InputToken::REGISTER, new AdlExprNode(tk_cr5 - 1000) }; +InputToken Tokencr6{ InputToken::REGISTER, new AdlExprNode(tk_cr6 - 1000) }; +InputToken Tokencr7{ InputToken::REGISTER, new AdlExprNode(tk_cr7 - 1000) }; +InputToken Tokendr0{ InputToken::REGISTER, new AdlExprNode(tk_dr0 - 1000) }; +InputToken Tokendr1{ InputToken::REGISTER, new AdlExprNode(tk_dr1 - 1000) }; +InputToken Tokendr2{ InputToken::REGISTER, new AdlExprNode(tk_dr2 - 1000) }; +InputToken Tokendr3{ InputToken::REGISTER, new AdlExprNode(tk_dr3 - 1000) }; +InputToken Tokendr4{ InputToken::REGISTER, new AdlExprNode(tk_dr4 - 1000) }; +InputToken Tokendr5{ InputToken::REGISTER, new AdlExprNode(tk_dr5 - 1000) }; +InputToken Tokendr6{ InputToken::REGISTER, new AdlExprNode(tk_dr6 - 1000) }; +InputToken Tokendr7{ InputToken::REGISTER, new AdlExprNode(tk_dr7 - 1000) }; +InputToken Tokentr0{ InputToken::REGISTER, new AdlExprNode(tk_tr0 - 1000) }; +InputToken Tokentr1{ InputToken::REGISTER, new AdlExprNode(tk_tr1 - 1000) }; +InputToken Tokentr2{ InputToken::REGISTER, new AdlExprNode(tk_tr2 - 1000) }; +InputToken Tokentr3{ InputToken::REGISTER, new AdlExprNode(tk_tr3 - 1000) }; +InputToken Tokentr4{ InputToken::REGISTER, new AdlExprNode(tk_tr4 - 1000) }; +InputToken Tokentr5{ InputToken::REGISTER, new AdlExprNode(tk_tr5 - 1000) }; +InputToken Tokentr6{ InputToken::REGISTER, new AdlExprNode(tk_tr6 - 1000) }; +InputToken Tokentr7{ InputToken::REGISTER, new AdlExprNode(tk_tr7 - 1000) }; diff --git a/src/oasm/x64Instructions.h b/src/oasm/x64Instructions.h index 0dac0860d..3b26a5c32 100644 --- a/src/oasm/x64Instructions.h +++ b/src/oasm/x64Instructions.h @@ -4,761 +4,759 @@ #include "InstructionParser.h" -enum e_opcode -{ - op_aaa = 32, - op_aad = 33, - op_aam = 34, - op_aas = 35, - op_adc = 36, - op_add = 37, - op_and = 38, - op_arpl = 39, - op_bound = 40, - op_bsf = 41, - op_bsr = 42, - op_bswap = 43, - op_bt = 44, - op_btc = 45, - op_btr = 46, - op_bts = 47, - op_call = 48, - op_cbw = 49, - op_cdq = 50, - op_cdqe = 51, - op_clc = 52, - op_cld = 53, - op_cli = 54, - op_clts = 55, - op_cmc = 56, - op_cmova = 57, - op_cmovae = 58, - op_cmovb = 59, - op_cmovbe = 60, - op_cmovc = 61, - op_cmove = 62, - op_cmovg = 63, - op_cmovge = 64, - op_cmovl = 65, - op_cmovle = 66, - op_cmovna = 67, - op_cmovnae = 68, - op_cmovnb = 69, - op_cmovnbe = 70, - op_cmovnc = 71, - op_cmovne = 72, - op_cmovng = 73, - op_cmovnge = 74, - op_cmovnl = 75, - op_cmovnle = 76, - op_cmovno = 77, - op_cmovnp = 78, - op_cmovns = 79, - op_cmovnz = 80, - op_cmovo = 81, - op_cmovp = 82, - op_cmovpe = 83, - op_cmovpo = 84, - op_cmovs = 85, - op_cmovz = 86, - op_cmp = 87, - op_cmps = 88, - op_cmpsb = 89, - op_cmpsw = 90, - op_cmpsd = 91, - op_cmpsq = 92, - op_cmpxchg = 93, - op_cmpxchg8b = 94, - op_cmpxchg16b = 95, - op_cpuid = 96, - op_cqo = 97, - op_cwd = 98, - op_cwde = 99, - op_daa = 100, - op_das = 101, - op_dec = 102, - op_div = 103, - op_enter = 104, - op_esc = 105, - op_f2xm1 = 106, - op_fabs = 107, - op_fadd = 108, - op_faddp = 109, - op_fbld = 110, - op_fbstp = 111, - op_fchs = 112, - op_fclex = 113, - op_fnclex = 114, - op_fcmovb = 115, - op_fcmovbe = 116, - op_fcmove = 117, - op_fcmovnb = 118, - op_fcmovnbe = 119, - op_fcmovne = 120, - op_fcmovnu = 121, - op_fcmovu = 122, - op_fcom = 123, - op_fcomi = 124, - op_fcomip = 125, - op_fcomp = 126, - op_fcompp = 127, - op_fcos = 128, - op_fdecstp = 129, - op_fdisi = 130, - op_fdiv = 131, - op_fdivp = 132, - op_fdivr = 133, - op_fdivrp = 134, - op_feni = 135, - op_ffree = 136, - op_ffreep = 137, - op_fiadd = 138, - op_ficom = 139, - op_ficomp = 140, - op_fidiv = 141, - op_fidivr = 142, - op_fild = 143, - op_fimul = 144, - op_fincstp = 145, - op_finit = 146, - op_fninit = 147, - op_fist = 148, - op_fistp = 149, - op_fisub = 150, - op_fisubr = 151, - op_fld = 152, - op_fld1 = 153, - op_fldcw = 154, - op_fldenv = 155, - op_fldl2e = 156, - op_fldl2t = 157, - op_fldlg2 = 158, - op_fldln2 = 159, - op_fldpi = 160, - op_fldz = 161, - op_fmul = 162, - op_fmulp = 163, - op_fnop = 164, - op_fnsave = 165, - op_fpatan = 166, - op_fprem = 167, - op_fprem1 = 168, - op_fptan = 169, - op_frndint = 170, - op_frstor = 171, - op_fsave = 172, - op_fscale = 173, - op_fsetpm = 174, - op_fsin = 175, - op_fsincos = 176, - op_fsqrt = 177, - op_fst = 178, - op_fstcw = 179, - op_fnstcw = 180, - op_fstenv = 181, - op_fnstenv = 182, - op_fstp = 183, - op_fstsw = 184, - op_fnstsw = 185, - op_fsub = 186, - op_fsubp = 187, - op_fsubr = 188, - op_fsubrp = 189, - op_ftst = 190, - op_fucom = 191, - op_fucomi = 192, - op_fucomip = 193, - op_fucomp = 194, - op_fucompp = 195, - op_fwait = 196, - op_fxam = 197, - op_fxch = 198, - op_fxch4 = 199, - op_fxch7 = 200, - op_fxrstor = 201, - op_fxsave = 202, - op_fxtract = 203, - op_fyl2x = 204, - op_fyl2xp1 = 205, - op_hlt = 206, - op_icebp = 207, - op_idiv = 208, - op_imul = 209, - op_in = 210, - op_ins = 211, - op_insb = 212, - op_insw = 213, - op_insd = 214, - op_inc = 215, - op_int = 216, - op_int1 = 217, - op_int3 = 218, - op_into = 219, - op_invd = 220, - op_invlpg = 221, - op_iret = 222, - op_iretw = 223, - op_iretd = 224, - op_iretq = 225, - op_ja = 226, - op_jae = 227, - op_jb = 228, - op_jbe = 229, - op_jc = 230, - op_jcxz = 231, - op_jecxz = 232, - op_je = 233, - op_jg = 234, - op_jge = 235, - op_jl = 236, - op_jle = 237, - op_jmp = 238, - op_jna = 239, - op_jnae = 240, - op_jnb = 241, - op_jnbe = 242, - op_jnc = 243, - op_jne = 244, - op_jng = 245, - op_jnge = 246, - op_jnl = 247, - op_jnle = 248, - op_jno = 249, - op_jnp = 250, - op_jns = 251, - op_jnz = 252, - op_jo = 253, - op_jp = 254, - op_jpe = 255, - op_jpo = 256, - op_js = 257, - op_jz = 258, - op_lahf = 259, - op_lar = 260, - op_lds = 261, - op_lea = 262, - op_leave = 263, - op_les = 264, - op_lfence = 265, - op_lfs = 266, - op_lgdt = 267, - op_lgs = 268, - op_lidt = 269, - op_lldt = 270, - op_lmsw = 271, - op_lods = 272, - op_lodsb = 273, - op_lodsw = 274, - op_lodsd = 275, - op_lodsq = 276, - op_loop = 277, - op_loope = 278, - op_loopne = 279, - op_loopnz = 280, - op_loopz = 281, - op_lsl = 282, - op_lss = 283, - op_ltr = 284, - op_mov = 285, - op_movs = 286, - op_movbe = 287, - op_movsb = 288, - op_movsw = 289, - op_movsd = 290, - op_movsq = 291, - op_movsx = 292, - op_movzx = 293, - op_movsxd = 294, - op_mul = 295, - op_neg = 296, - op_nop = 297, - op_not = 298, - op_or = 299, - op_out = 300, - op_outs = 301, - op_outsb = 302, - op_outsw = 303, - op_outsd = 304, - op_pop = 305, - op_popa = 306, - op_popaw = 307, - op_popad = 308, - op_popcnt = 309, - op_popf = 310, - op_popfw = 311, - op_popfd = 312, - op_popfq = 313, - op_prefetchnta = 314, - op_prefetcht0 = 315, - op_prefetcht1 = 316, - op_prefetcht2 = 317, - op_push = 318, - op_pusha = 319, - op_pushaw = 320, - op_pushad = 321, - op_pushf = 322, - op_pushfw = 323, - op_pushfd = 324, - op_pushfq = 325, - op_rcl = 326, - op_rcr = 327, - op_rdmsr = 328, - op_rdpmc = 329, - op_rdtsc = 330, - op_ret = 331, - op_retf = 332, - op_rol = 333, - op_ror = 334, - op_rsm = 335, - op_sahf = 336, - op_sal = 337, - op_sar = 338, - op_sbb = 339, - op_scas = 340, - op_scasb = 341, - op_scasw = 342, - op_scasd = 343, - op_scasq = 344, - op_seta = 345, - op_setae = 346, - op_setb = 347, - op_setbe = 348, - op_setc = 349, - op_sete = 350, - op_setg = 351, - op_setge = 352, - op_setl = 353, - op_setle = 354, - op_setna = 355, - op_setnae = 356, - op_setnb = 357, - op_setnbe = 358, - op_setnc = 359, - op_setne = 360, - op_setng = 361, - op_setnge = 362, - op_setnl = 363, - op_setnle = 364, - op_setno = 365, - op_setnp = 366, - op_setns = 367, - op_setnz = 368, - op_seto = 369, - op_setp = 370, - op_setpe = 371, - op_setpo = 372, - op_sets = 373, - op_setz = 374, - op_sfence = 375, - op_sgdt = 376, - op_shl = 377, - op_shld = 378, - op_shr = 379, - op_shrd = 380, - op_sidt = 381, - op_sldt = 382, - op_smsw = 383, - op_stc = 384, - op_std = 385, - op_sti = 386, - op_stos = 387, - op_stosb = 388, - op_stosw = 389, - op_stosd = 390, - op_stosq = 391, - op_str = 392, - op_sub = 393, - op_syscall = 394, - op_sysenter = 395, - op_sysexit = 396, - op_sysret = 397, - op_test = 398, - op_ud2 = 399, - op_verr = 400, - op_verw = 401, - op_wait = 402, - op_wbinvd = 403, - op_wrmsr = 404, - op_xadd = 405, - op_xchg = 406, - op_xlat = 407, - op_xlatb = 408, - op_xor = 409, - op_xrstor = 410, - op_xrstor64 = 411, - op_xsave = 412, - op_xsave64 = 413, - op_xsetbv = 414, - op_addpd = 415, - op_addps = 416, - op_addsd = 417, - op_addss = 418, - op_addsubpd = 419, - op_addsubps = 420, - op_andnpd = 421, - op_andnps = 422, - op_andpd = 423, - op_andps = 424, - op_blendpd = 425, - op_blendps = 426, - op_cmppd = 427, - op_cmpps = 428, - op_comisd = 429, - op_comiss = 430, - op_cvtdq2pd = 431, - op_cvtdq2ps = 432, - op_cvtpd2dq = 433, - op_cvtpd2pi = 434, - op_cvtpd2ps = 435, - op_cvtpi2pd = 436, - op_cvtpi2ps = 437, - op_cvtps2dq = 438, - op_cvtps2pd = 439, - op_cvtps2pi = 440, - op_cvtsd2si = 441, - op_cvtsd2ss = 442, - op_cvtsi2sd = 443, - op_cvtsi2ss = 444, - op_cvtss2sd = 445, - op_cvtss2si = 446, - op_cvttpd2dq = 447, - op_cvttpd2pi = 448, - op_cvttps2dq = 449, - op_cvttps2pi = 450, - op_cvttsd2si = 451, - op_cvttss2si = 452, - op_divpd = 453, - op_divps = 454, - op_divsd = 455, - op_divss = 456, - op_dppd = 457, - op_dpps = 458, - op_hsubpd = 459, - op_hsubps = 460, - op_insertps = 461, - op_lddqu = 462, - op_maskmovdqu = 463, - op_maskmovq = 464, - op_maxpd = 465, - op_maxps = 466, - op_maxsd = 467, - op_maxss = 468, - op_mfence = 469, - op_pause = 470, - op_minpd = 471, - op_minps = 472, - op_minsd = 473, - op_minss = 474, - op_monitor = 475, - op_movapd = 476, - op_movaps = 477, - op_movd = 478, - op_movq = 479, - op_movddup = 480, - op_movdq2q = 481, - op_movdqa = 482, - op_movdqu = 483, - op_movhlps = 484, - op_movhpd = 485, - op_movhps = 486, - op_movlhps = 487, - op_movlpd = 488, - op_movlps = 489, - op_movmskpd = 490, - op_movmskps = 491, - op_movntdq = 492, - op_movnti = 493, - op_movntpd = 494, - op_movntd = 495, - op_movntq = 496, - op_movq2dq = 497, - op_movshdup = 498, - op_movsldup = 499, - op_movss = 500, - op_movupd = 501, - op_movups = 502, - op_mpsadbw = 503, - op_mulpd = 504, - op_mulps = 505, - op_mulsd = 506, - op_mulss = 507, - op_orpd = 508, - op_orps = 509, - op_packssdw = 510, - op_packsswb = 511, - op_packusdw = 512, - op_paddb = 513, - op_paddd = 514, - op_paddq = 515, - op_paddsw = 516, - op_paddusb = 517, - op_paddusw = 518, - op_paddw = 519, - op_palignr = 520, - op_pand = 521, - op_pandn = 522, - op_pavgb = 523, - op_pavgw = 524, - op_pblendw = 525, - op_pcmpeqb = 526, - op_pcmpeqd = 527, - op_pcmpeqw = 528, - op_pcmpestri = 529, - op_pcmpestrm = 530, - op_pcmpgtb = 531, - op_pcmpgtd = 532, - op_pcmpgtw = 533, - op_pextrb = 534, - op_pextrd = 535, - op_pextrq = 536, - op_pextrw = 537, - op_pinsrb = 538, - op_pinsrd = 539, - op_pinsrq = 540, - op_pinsrw = 541, - op_pmaddwd = 542, - op_pmaxsw = 543, - op_pmaxub = 544, - op_pminsw = 545, - op_pminub = 546, - op_pmovmskb = 547, - op_pmulhuw = 548, - op_pmulhw = 549, - op_pmullw = 550, - op_pmuludq = 551, - op_psadbw = 552, - op_pshufd = 553, - op_pshufhw = 554, - op_pshuflw = 555, - op_pshufw = 556, - op_pslld = 557, - op_pslldq = 558, - op_psllq = 559, - op_psllw = 560, - op_psrad = 561, - op_psraw = 562, - op_psrld = 563, - op_psrldq = 564, - op_psrlq = 565, - op_psrlw = 566, - op_psubb = 567, - op_psubd = 568, - op_psubq = 569, - op_psubsb = 570, - op_psubsw = 571, - op_psubusb = 572, - op_psubusw = 573, - op_punpckhbw = 574, - op_punpckhdq = 575, - op_punpckhqdq = 576, - op_punpckhwd = 577, - op_punpcklbw = 578, - op_punpckldq = 579, - op_punpcklqdq = 580, - op_punpcklwd = 581, - op_pxor = 582, - op_rcpps = 583, - op_rcpss = 584, - op_roundpd = 585, - op_roundps = 586, - op_roundsd = 587, - op_roundss = 588, - op_rsqrtps = 589, - op_rsqrtss = 590, - op_shufpd = 591, - op_shufps = 592, - op_sqrtpd = 593, - op_sqrtps = 594, - op_sqrtsd = 595, - op_sqrtss = 596, - op_subpd = 597, - op_subps = 598, - op_subsd = 599, - op_subss = 600, - op_ucomisd = 601, - op_ucomiss = 602, - op_unpckhpd = 603, - op_unpckhps = 604, - op_unpcklpd = 605, - op_unpcklps = 606, - op_xorpd = 607, - op_xorps = 608, - op_invept = 609, - op_invvpid = 610, - op_vmcall = 611, - op_vmclear = 612, - op_vmlaunch = 613, - op_vmptrld = 614, - op_vmptrst = 615, - op_vmread = 616, - op_vmresume = 617, - op_vmwrite = 618, - op_vmxoff = 619, - op_vmxon = 620, - op_a16 = 621, - op_a32 = 622, - op_lock = 623, - op_o16 = 624, - op_o32 = 625, - op_rep = 626, - op_repe = 627, - op_repne = 628, - op_repnz = 629, - op_repz = 630, +enum e_opcode { + op_aaa = 32, + op_aad = 33, + op_aam = 34, + op_aas = 35, + op_adc = 36, + op_add = 37, + op_and = 38, + op_arpl = 39, + op_bound = 40, + op_bsf = 41, + op_bsr = 42, + op_bswap = 43, + op_bt = 44, + op_btc = 45, + op_btr = 46, + op_bts = 47, + op_call = 48, + op_cbw = 49, + op_cdq = 50, + op_cdqe = 51, + op_clc = 52, + op_cld = 53, + op_cli = 54, + op_clts = 55, + op_cmc = 56, + op_cmova = 57, + op_cmovae = 58, + op_cmovb = 59, + op_cmovbe = 60, + op_cmovc = 61, + op_cmove = 62, + op_cmovg = 63, + op_cmovge = 64, + op_cmovl = 65, + op_cmovle = 66, + op_cmovna = 67, + op_cmovnae = 68, + op_cmovnb = 69, + op_cmovnbe = 70, + op_cmovnc = 71, + op_cmovne = 72, + op_cmovng = 73, + op_cmovnge = 74, + op_cmovnl = 75, + op_cmovnle = 76, + op_cmovno = 77, + op_cmovnp = 78, + op_cmovns = 79, + op_cmovnz = 80, + op_cmovo = 81, + op_cmovp = 82, + op_cmovpe = 83, + op_cmovpo = 84, + op_cmovs = 85, + op_cmovz = 86, + op_cmp = 87, + op_cmps = 88, + op_cmpsb = 89, + op_cmpsw = 90, + op_cmpsd = 91, + op_cmpsq = 92, + op_cmpxchg = 93, + op_cmpxchg8b = 94, + op_cmpxchg16b = 95, + op_cpuid = 96, + op_cqo = 97, + op_cwd = 98, + op_cwde = 99, + op_daa = 100, + op_das = 101, + op_dec = 102, + op_div = 103, + op_enter = 104, + op_esc = 105, + op_f2xm1 = 106, + op_fabs = 107, + op_fadd = 108, + op_faddp = 109, + op_fbld = 110, + op_fbstp = 111, + op_fchs = 112, + op_fclex = 113, + op_fnclex = 114, + op_fcmovb = 115, + op_fcmovbe = 116, + op_fcmove = 117, + op_fcmovnb = 118, + op_fcmovnbe = 119, + op_fcmovne = 120, + op_fcmovnu = 121, + op_fcmovu = 122, + op_fcom = 123, + op_fcomi = 124, + op_fcomip = 125, + op_fcomp = 126, + op_fcompp = 127, + op_fcos = 128, + op_fdecstp = 129, + op_fdisi = 130, + op_fdiv = 131, + op_fdivp = 132, + op_fdivr = 133, + op_fdivrp = 134, + op_feni = 135, + op_ffree = 136, + op_ffreep = 137, + op_fiadd = 138, + op_ficom = 139, + op_ficomp = 140, + op_fidiv = 141, + op_fidivr = 142, + op_fild = 143, + op_fimul = 144, + op_fincstp = 145, + op_finit = 146, + op_fninit = 147, + op_fist = 148, + op_fistp = 149, + op_fisub = 150, + op_fisubr = 151, + op_fld = 152, + op_fld1 = 153, + op_fldcw = 154, + op_fldenv = 155, + op_fldl2e = 156, + op_fldl2t = 157, + op_fldlg2 = 158, + op_fldln2 = 159, + op_fldpi = 160, + op_fldz = 161, + op_fmul = 162, + op_fmulp = 163, + op_fnop = 164, + op_fnsave = 165, + op_fpatan = 166, + op_fprem = 167, + op_fprem1 = 168, + op_fptan = 169, + op_frndint = 170, + op_frstor = 171, + op_fsave = 172, + op_fscale = 173, + op_fsetpm = 174, + op_fsin = 175, + op_fsincos = 176, + op_fsqrt = 177, + op_fst = 178, + op_fstcw = 179, + op_fnstcw = 180, + op_fstenv = 181, + op_fnstenv = 182, + op_fstp = 183, + op_fstsw = 184, + op_fnstsw = 185, + op_fsub = 186, + op_fsubp = 187, + op_fsubr = 188, + op_fsubrp = 189, + op_ftst = 190, + op_fucom = 191, + op_fucomi = 192, + op_fucomip = 193, + op_fucomp = 194, + op_fucompp = 195, + op_fwait = 196, + op_fxam = 197, + op_fxch = 198, + op_fxch4 = 199, + op_fxch7 = 200, + op_fxrstor = 201, + op_fxsave = 202, + op_fxtract = 203, + op_fyl2x = 204, + op_fyl2xp1 = 205, + op_hlt = 206, + op_icebp = 207, + op_idiv = 208, + op_imul = 209, + op_in = 210, + op_ins = 211, + op_insb = 212, + op_insw = 213, + op_insd = 214, + op_inc = 215, + op_int = 216, + op_int1 = 217, + op_int3 = 218, + op_into = 219, + op_invd = 220, + op_invlpg = 221, + op_iret = 222, + op_iretw = 223, + op_iretd = 224, + op_iretq = 225, + op_ja = 226, + op_jae = 227, + op_jb = 228, + op_jbe = 229, + op_jc = 230, + op_jcxz = 231, + op_jecxz = 232, + op_je = 233, + op_jg = 234, + op_jge = 235, + op_jl = 236, + op_jle = 237, + op_jmp = 238, + op_jna = 239, + op_jnae = 240, + op_jnb = 241, + op_jnbe = 242, + op_jnc = 243, + op_jne = 244, + op_jng = 245, + op_jnge = 246, + op_jnl = 247, + op_jnle = 248, + op_jno = 249, + op_jnp = 250, + op_jns = 251, + op_jnz = 252, + op_jo = 253, + op_jp = 254, + op_jpe = 255, + op_jpo = 256, + op_js = 257, + op_jz = 258, + op_lahf = 259, + op_lar = 260, + op_lds = 261, + op_lea = 262, + op_leave = 263, + op_les = 264, + op_lfence = 265, + op_lfs = 266, + op_lgdt = 267, + op_lgs = 268, + op_lidt = 269, + op_lldt = 270, + op_lmsw = 271, + op_lods = 272, + op_lodsb = 273, + op_lodsw = 274, + op_lodsd = 275, + op_lodsq = 276, + op_loop = 277, + op_loope = 278, + op_loopne = 279, + op_loopnz = 280, + op_loopz = 281, + op_lsl = 282, + op_lss = 283, + op_ltr = 284, + op_mov = 285, + op_movs = 286, + op_movbe = 287, + op_movsb = 288, + op_movsw = 289, + op_movsd = 290, + op_movsq = 291, + op_movsx = 292, + op_movzx = 293, + op_movsxd = 294, + op_mul = 295, + op_neg = 296, + op_nop = 297, + op_not = 298, + op_or = 299, + op_out = 300, + op_outs = 301, + op_outsb = 302, + op_outsw = 303, + op_outsd = 304, + op_pop = 305, + op_popa = 306, + op_popaw = 307, + op_popad = 308, + op_popcnt = 309, + op_popf = 310, + op_popfw = 311, + op_popfd = 312, + op_popfq = 313, + op_prefetchnta = 314, + op_prefetcht0 = 315, + op_prefetcht1 = 316, + op_prefetcht2 = 317, + op_push = 318, + op_pusha = 319, + op_pushaw = 320, + op_pushad = 321, + op_pushf = 322, + op_pushfw = 323, + op_pushfd = 324, + op_pushfq = 325, + op_rcl = 326, + op_rcr = 327, + op_rdmsr = 328, + op_rdpmc = 329, + op_rdtsc = 330, + op_ret = 331, + op_retf = 332, + op_rol = 333, + op_ror = 334, + op_rsm = 335, + op_sahf = 336, + op_sal = 337, + op_sar = 338, + op_sbb = 339, + op_scas = 340, + op_scasb = 341, + op_scasw = 342, + op_scasd = 343, + op_scasq = 344, + op_seta = 345, + op_setae = 346, + op_setb = 347, + op_setbe = 348, + op_setc = 349, + op_sete = 350, + op_setg = 351, + op_setge = 352, + op_setl = 353, + op_setle = 354, + op_setna = 355, + op_setnae = 356, + op_setnb = 357, + op_setnbe = 358, + op_setnc = 359, + op_setne = 360, + op_setng = 361, + op_setnge = 362, + op_setnl = 363, + op_setnle = 364, + op_setno = 365, + op_setnp = 366, + op_setns = 367, + op_setnz = 368, + op_seto = 369, + op_setp = 370, + op_setpe = 371, + op_setpo = 372, + op_sets = 373, + op_setz = 374, + op_sfence = 375, + op_sgdt = 376, + op_shl = 377, + op_shld = 378, + op_shr = 379, + op_shrd = 380, + op_sidt = 381, + op_sldt = 382, + op_smsw = 383, + op_stc = 384, + op_std = 385, + op_sti = 386, + op_stos = 387, + op_stosb = 388, + op_stosw = 389, + op_stosd = 390, + op_stosq = 391, + op_str = 392, + op_sub = 393, + op_syscall = 394, + op_sysenter = 395, + op_sysexit = 396, + op_sysret = 397, + op_test = 398, + op_ud2 = 399, + op_verr = 400, + op_verw = 401, + op_wait = 402, + op_wbinvd = 403, + op_wrmsr = 404, + op_xadd = 405, + op_xchg = 406, + op_xlat = 407, + op_xlatb = 408, + op_xor = 409, + op_xrstor = 410, + op_xrstor64 = 411, + op_xsave = 412, + op_xsave64 = 413, + op_xsetbv = 414, + op_addpd = 415, + op_addps = 416, + op_addsd = 417, + op_addss = 418, + op_addsubpd = 419, + op_addsubps = 420, + op_andnpd = 421, + op_andnps = 422, + op_andpd = 423, + op_andps = 424, + op_blendpd = 425, + op_blendps = 426, + op_cmppd = 427, + op_cmpps = 428, + op_comisd = 429, + op_comiss = 430, + op_cvtdq2pd = 431, + op_cvtdq2ps = 432, + op_cvtpd2dq = 433, + op_cvtpd2pi = 434, + op_cvtpd2ps = 435, + op_cvtpi2pd = 436, + op_cvtpi2ps = 437, + op_cvtps2dq = 438, + op_cvtps2pd = 439, + op_cvtps2pi = 440, + op_cvtsd2si = 441, + op_cvtsd2ss = 442, + op_cvtsi2sd = 443, + op_cvtsi2ss = 444, + op_cvtss2sd = 445, + op_cvtss2si = 446, + op_cvttpd2dq = 447, + op_cvttpd2pi = 448, + op_cvttps2dq = 449, + op_cvttps2pi = 450, + op_cvttsd2si = 451, + op_cvttss2si = 452, + op_divpd = 453, + op_divps = 454, + op_divsd = 455, + op_divss = 456, + op_dppd = 457, + op_dpps = 458, + op_hsubpd = 459, + op_hsubps = 460, + op_insertps = 461, + op_lddqu = 462, + op_maskmovdqu = 463, + op_maskmovq = 464, + op_maxpd = 465, + op_maxps = 466, + op_maxsd = 467, + op_maxss = 468, + op_mfence = 469, + op_pause = 470, + op_minpd = 471, + op_minps = 472, + op_minsd = 473, + op_minss = 474, + op_monitor = 475, + op_movapd = 476, + op_movaps = 477, + op_movd = 478, + op_movq = 479, + op_movddup = 480, + op_movdq2q = 481, + op_movdqa = 482, + op_movdqu = 483, + op_movhlps = 484, + op_movhpd = 485, + op_movhps = 486, + op_movlhps = 487, + op_movlpd = 488, + op_movlps = 489, + op_movmskpd = 490, + op_movmskps = 491, + op_movntdq = 492, + op_movnti = 493, + op_movntpd = 494, + op_movntd = 495, + op_movntq = 496, + op_movq2dq = 497, + op_movshdup = 498, + op_movsldup = 499, + op_movss = 500, + op_movupd = 501, + op_movups = 502, + op_mpsadbw = 503, + op_mulpd = 504, + op_mulps = 505, + op_mulsd = 506, + op_mulss = 507, + op_orpd = 508, + op_orps = 509, + op_packssdw = 510, + op_packsswb = 511, + op_packusdw = 512, + op_paddb = 513, + op_paddd = 514, + op_paddq = 515, + op_paddsw = 516, + op_paddusb = 517, + op_paddusw = 518, + op_paddw = 519, + op_palignr = 520, + op_pand = 521, + op_pandn = 522, + op_pavgb = 523, + op_pavgw = 524, + op_pblendw = 525, + op_pcmpeqb = 526, + op_pcmpeqd = 527, + op_pcmpeqw = 528, + op_pcmpestri = 529, + op_pcmpestrm = 530, + op_pcmpgtb = 531, + op_pcmpgtd = 532, + op_pcmpgtw = 533, + op_pextrb = 534, + op_pextrd = 535, + op_pextrq = 536, + op_pextrw = 537, + op_pinsrb = 538, + op_pinsrd = 539, + op_pinsrq = 540, + op_pinsrw = 541, + op_pmaddwd = 542, + op_pmaxsw = 543, + op_pmaxub = 544, + op_pminsw = 545, + op_pminub = 546, + op_pmovmskb = 547, + op_pmulhuw = 548, + op_pmulhw = 549, + op_pmullw = 550, + op_pmuludq = 551, + op_psadbw = 552, + op_pshufd = 553, + op_pshufhw = 554, + op_pshuflw = 555, + op_pshufw = 556, + op_pslld = 557, + op_pslldq = 558, + op_psllq = 559, + op_psllw = 560, + op_psrad = 561, + op_psraw = 562, + op_psrld = 563, + op_psrldq = 564, + op_psrlq = 565, + op_psrlw = 566, + op_psubb = 567, + op_psubd = 568, + op_psubq = 569, + op_psubsb = 570, + op_psubsw = 571, + op_psubusb = 572, + op_psubusw = 573, + op_punpckhbw = 574, + op_punpckhdq = 575, + op_punpckhqdq = 576, + op_punpckhwd = 577, + op_punpcklbw = 578, + op_punpckldq = 579, + op_punpcklqdq = 580, + op_punpcklwd = 581, + op_pxor = 582, + op_rcpps = 583, + op_rcpss = 584, + op_roundpd = 585, + op_roundps = 586, + op_roundsd = 587, + op_roundss = 588, + op_rsqrtps = 589, + op_rsqrtss = 590, + op_shufpd = 591, + op_shufps = 592, + op_sqrtpd = 593, + op_sqrtps = 594, + op_sqrtsd = 595, + op_sqrtss = 596, + op_subpd = 597, + op_subps = 598, + op_subsd = 599, + op_subss = 600, + op_ucomisd = 601, + op_ucomiss = 602, + op_unpckhpd = 603, + op_unpckhps = 604, + op_unpcklpd = 605, + op_unpcklps = 606, + op_xorpd = 607, + op_xorps = 608, + op_invept = 609, + op_invvpid = 610, + op_vmcall = 611, + op_vmclear = 612, + op_vmlaunch = 613, + op_vmptrld = 614, + op_vmptrst = 615, + op_vmread = 616, + op_vmresume = 617, + op_vmwrite = 618, + op_vmxoff = 619, + op_vmxon = 620, + op_a16 = 621, + op_a32 = 622, + op_lock = 623, + op_o16 = 624, + op_o32 = 625, + op_rep = 626, + op_repe = 627, + op_repne = 628, + op_repnz = 629, + op_repz = 630, }; -enum e_tk -{ - tk_star = 5, - tk_plus = 4, - tk_comma = 7, - tk_colon = 3, - tk_openbr = 1, - tk_closebr = 2, - tk_byte = 11, - tk_dword = 9, - tk_far = 15, - tk_near = 14, - tk_qword = 10, - tk_short = 13, - tk_tword = 12, - tk_word = 8, - tk_al = 1000, - tk_ah = 1001, - tk_ax = 1002, - tk_eax = 1003, - tk_rax = 1004, - tk_r8b = 1005, - tk_r8w = 1006, - tk_r8d = 1007, - tk_r8 = 1008, - tk_cl = 1009, - tk_ch = 1010, - tk_cx = 1011, - tk_ecx = 1012, - tk_rcx = 1013, - tk_r9b = 1014, - tk_r9w = 1015, - tk_r9d = 1016, - tk_r9 = 1017, - tk_dl = 1018, - tk_dh = 1019, - tk_dx = 1020, - tk_edx = 1021, - tk_rdx = 1022, - tk_r10b = 1023, - tk_r10w = 1024, - tk_r10d = 1025, - tk_r10 = 1026, - tk_bl = 1027, - tk_bh = 1028, - tk_bx = 1029, - tk_ebx = 1030, - tk_rbx = 1031, - tk_r11b = 1032, - tk_r11w = 1033, - tk_r11d = 1034, - tk_r11 = 1035, - tk_spl = 1036, - tk_sp = 1037, - tk_esp = 1038, - tk_rsp = 1039, - tk_r12b = 1040, - tk_r12w = 1041, - tk_r12d = 1042, - tk_r12 = 1043, - tk_bpl = 1044, - tk_bp = 1045, - tk_ebp = 1046, - tk_rbp = 1047, - tk_r13b = 1048, - tk_r13w = 1049, - tk_r13d = 1050, - tk_r13 = 1051, - tk_sil = 1052, - tk_si = 1053, - tk_esi = 1054, - tk_rsi = 1055, - tk_r14b = 1056, - tk_r14w = 1057, - tk_r14d = 1058, - tk_r14 = 1059, - tk_dil = 1060, - tk_di = 1061, - tk_edi = 1062, - tk_rdi = 1063, - tk_r15b = 1064, - tk_r15w = 1065, - tk_r15d = 1066, - tk_r15 = 1067, - tk_rip = 1068, - tk_mm0 = 1069, - tk_xmm0 = 1070, - tk_xmm8 = 1071, - tk_mm1 = 1072, - tk_xmm1 = 1073, - tk_xmm9 = 1074, - tk_mm2 = 1075, - tk_xmm2 = 1076, - tk_xmm10 = 1077, - tk_mm3 = 1078, - tk_xmm3 = 1079, - tk_xmm11 = 1080, - tk_mm4 = 1081, - tk_xmm4 = 1082, - tk_xmm12 = 1083, - tk_mm5 = 1084, - tk_xmm5 = 1085, - tk_xmm13 = 1086, - tk_mm6 = 1087, - tk_xmm6 = 1088, - tk_xmm14 = 1089, - tk_mm7 = 1090, - tk_xmm7 = 1091, - tk_xmm15 = 1092, - tk_es = 1093, - tk_cs = 1094, - tk_ss = 1095, - tk_ds = 1096, - tk_fs = 1097, - tk_gs = 1098, - tk_st0 = 1099, - tk_st1 = 1100, - tk_st2 = 1101, - tk_st3 = 1102, - tk_st4 = 1103, - tk_st5 = 1104, - tk_st6 = 1105, - tk_st7 = 1106, - tk_cr0 = 1107, - tk_cr1 = 1108, - tk_cr2 = 1109, - tk_cr3 = 1110, - tk_cr4 = 1111, - tk_cr5 = 1112, - tk_cr6 = 1113, - tk_cr7 = 1114, - tk_dr0 = 1115, - tk_dr1 = 1116, - tk_dr2 = 1117, - tk_dr3 = 1118, - tk_dr4 = 1119, - tk_dr5 = 1120, - tk_dr6 = 1121, - tk_dr7 = 1122, - tk_tr0 = 1123, - tk_tr1 = 1124, - tk_tr2 = 1125, - tk_tr3 = 1126, - tk_tr4 = 1127, - tk_tr5 = 1128, - tk_tr6 = 1129, - tk_tr7 = 1130, +enum e_tk { + tk_star= 5, + tk_plus= 4, + tk_comma= 7, + tk_colon= 3, + tk_openbr= 1, + tk_closebr= 2, + tk_byte= 11, + tk_dword= 9, + tk_far= 15, + tk_near= 14, + tk_qword= 10, + tk_short= 13, + tk_tword= 12, + tk_word= 8, + tk_al = 1000, + tk_ah = 1001, + tk_ax = 1002, + tk_eax = 1003, + tk_rax = 1004, + tk_r8b = 1005, + tk_r8w = 1006, + tk_r8d = 1007, + tk_r8 = 1008, + tk_cl = 1009, + tk_ch = 1010, + tk_cx = 1011, + tk_ecx = 1012, + tk_rcx = 1013, + tk_r9b = 1014, + tk_r9w = 1015, + tk_r9d = 1016, + tk_r9 = 1017, + tk_dl = 1018, + tk_dh = 1019, + tk_dx = 1020, + tk_edx = 1021, + tk_rdx = 1022, + tk_r10b = 1023, + tk_r10w = 1024, + tk_r10d = 1025, + tk_r10 = 1026, + tk_bl = 1027, + tk_bh = 1028, + tk_bx = 1029, + tk_ebx = 1030, + tk_rbx = 1031, + tk_r11b = 1032, + tk_r11w = 1033, + tk_r11d = 1034, + tk_r11 = 1035, + tk_spl = 1036, + tk_sp = 1037, + tk_esp = 1038, + tk_rsp = 1039, + tk_r12b = 1040, + tk_r12w = 1041, + tk_r12d = 1042, + tk_r12 = 1043, + tk_bpl = 1044, + tk_bp = 1045, + tk_ebp = 1046, + tk_rbp = 1047, + tk_r13b = 1048, + tk_r13w = 1049, + tk_r13d = 1050, + tk_r13 = 1051, + tk_sil = 1052, + tk_si = 1053, + tk_esi = 1054, + tk_rsi = 1055, + tk_r14b = 1056, + tk_r14w = 1057, + tk_r14d = 1058, + tk_r14 = 1059, + tk_dil = 1060, + tk_di = 1061, + tk_edi = 1062, + tk_rdi = 1063, + tk_r15b = 1064, + tk_r15w = 1065, + tk_r15d = 1066, + tk_r15 = 1067, + tk_rip = 1068, + tk_mm0 = 1069, + tk_xmm0 = 1070, + tk_xmm8 = 1071, + tk_mm1 = 1072, + tk_xmm1 = 1073, + tk_xmm9 = 1074, + tk_mm2 = 1075, + tk_xmm2 = 1076, + tk_xmm10 = 1077, + tk_mm3 = 1078, + tk_xmm3 = 1079, + tk_xmm11 = 1080, + tk_mm4 = 1081, + tk_xmm4 = 1082, + tk_xmm12 = 1083, + tk_mm5 = 1084, + tk_xmm5 = 1085, + tk_xmm13 = 1086, + tk_mm6 = 1087, + tk_xmm6 = 1088, + tk_xmm14 = 1089, + tk_mm7 = 1090, + tk_xmm7 = 1091, + tk_xmm15 = 1092, + tk_es = 1093, + tk_cs = 1094, + tk_ss = 1095, + tk_ds = 1096, + tk_fs = 1097, + tk_gs = 1098, + tk_st0 = 1099, + tk_st1 = 1100, + tk_st2 = 1101, + tk_st3 = 1102, + tk_st4 = 1103, + tk_st5 = 1104, + tk_st6 = 1105, + tk_st7 = 1106, + tk_cr0 = 1107, + tk_cr1 = 1108, + tk_cr2 = 1109, + tk_cr3 = 1110, + tk_cr4 = 1111, + tk_cr5 = 1112, + tk_cr6 = 1113, + tk_cr7 = 1114, + tk_dr0 = 1115, + tk_dr1 = 1116, + tk_dr2 = 1117, + tk_dr3 = 1118, + tk_dr4 = 1119, + tk_dr5 = 1120, + tk_dr6 = 1121, + tk_dr7 = 1122, + tk_tr0 = 1123, + tk_tr1 = 1124, + tk_tr2 = 1125, + tk_tr3 = 1126, + tk_tr4 = 1127, + tk_tr5 = 1128, + tk_tr6 = 1129, + tk_tr7 = 1130, }; -extern const char* const opcodeTable[631]; +extern const char * const opcodeTable[631]; -extern std::unordered_map tokenNames; +extern std::unordered_map tokenNames; extern InputToken Tokenstar; extern InputToken Tokenplus; diff --git a/src/oasm/x64Operand.h b/src/oasm/x64Operand.h index 6eed4d693..db75c2c45 100644 --- a/src/oasm/x64Operand.h +++ b/src/oasm/x64Operand.h @@ -7,34 +7,28 @@ class x64Parser; class Coding; static const int OPARRAY_SIZE = 40; class x64Operand -{ - public: - x64Operand() : opcode(-1), addressCoding(-1), operandCoding(-1) { Clear(); } - void Clear() { memset(values, 0, sizeof(values)); } - int opcode; - int addressCoding; - int operandCoding; - Coding* values[OPARRAY_SIZE]; -}; +{ +public: + x64Operand() : opcode(-1), addressCoding(-1), operandCoding(-1) { Clear(); } + void Clear() { memset(values, 0, sizeof(values)); } + int opcode; + int addressCoding; + int operandCoding; + Coding *values[OPARRAY_SIZE]; +}; struct x64Token { - enum - { - EOT, - TOKEN, - REGISTER, - REGISTERCLASS, - ADDRESSCLASS, - NUMBER, - EMPTY - } type; - unsigned char id; - unsigned char eos; - unsigned char level; - unsigned char* addrClass; - void (x64Parser::*tokenFunc)(x64Operand& operand, int tokenPos); - x64Token* next; + enum + { + EOT, TOKEN, REGISTER, REGISTERCLASS, ADDRESSCLASS, NUMBER, EMPTY + } type; + unsigned char id; + unsigned char eos; + unsigned char level; + unsigned char *addrClass; + void (x64Parser::*tokenFunc)(x64Operand& operand, int tokenPos); + x64Token *next; }; #endif diff --git a/src/oasm/x64Parser.cpp b/src/oasm/x64Parser.cpp index e12352d5f..457accef1 100644 --- a/src/oasm/x64Parser.cpp +++ b/src/oasm/x64Parser.cpp @@ -5,59820 +5,58095 @@ #include "x64Operand.h" #include "x64Parser.h" -Coding x64Parser::stateCoding_eot[] = {{Coding::eot}}; +Coding x64Parser::stateCoding_eot[] = { { Coding::eot } }; Coding x64Parser::stateCoding1_1[] = { - {CODING_NAME("addr16")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addr16") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding1_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding2_1[] = { - {CODING_NAME("addr32")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addr32") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding2_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding3_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding4_1[] = { - {CODING_NAME("data16")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("data16") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding4_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding5_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding5_2[] = { - {CODING_NAME("data32")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("data32") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding6_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding7_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding7_2[] = { - {CODING_NAME("no64") Coding::illegal}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("no64") Coding::illegal }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding8_1[] = { - {CODING_NAME("only64") Coding::illegal}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("only64") Coding::illegal }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding8_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding9_1[] = { - {CODING_NAME("rex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::StateFunc1() -{ - if (stateVars[0] != 16) - { - return stateCoding1_1; - } - if (stateVars[0] == 16) - { - return stateCoding1_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc2() -{ - if (stateVars[0] != 32) - { - return stateCoding2_1; - } - if (stateVars[0] == 32) - { - return stateCoding2_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc3() -{ - if (true) - { - return stateCoding3_1; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc4() -{ - if (stateVars[0] != 16) - { - return stateCoding4_1; - } - if (stateVars[0] == 16) - { - return stateCoding4_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc5() -{ - if (stateVars[0] != 16) - { - return stateCoding5_1; - } - if (stateVars[0] == 16) - { - return stateCoding5_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc6() -{ - if (true) - { - return stateCoding6_1; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc7() -{ - if (stateVars[0] != 64) - { - return stateCoding7_1; - } - if (stateVars[0] == 64) - { - return stateCoding7_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc8() -{ - if (stateVars[0] != 64) - { - return stateCoding8_1; - } - if (stateVars[0] == 64) - { - return stateCoding8_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc9() -{ - if (true) - { - return stateCoding9_1; - } - return stateCoding_eot; + { CODING_NAME("rex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding *x64Parser::StateFunc1() +{ + if (stateVars[0]!=16) + { + return stateCoding1_1; + } + if (stateVars[0]==16) + { + return stateCoding1_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc2() +{ + if (stateVars[0]!=32) + { + return stateCoding2_1; + } + if (stateVars[0]==32) + { + return stateCoding2_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc3() +{ + if (true) + { + return stateCoding3_1; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc4() +{ + if (stateVars[0]!=16) + { + return stateCoding4_1; + } + if (stateVars[0]==16) + { + return stateCoding4_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc5() +{ + if (stateVars[0]!=16) + { + return stateCoding5_1; + } + if (stateVars[0]==16) + { + return stateCoding5_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc6() +{ + if (true) + { + return stateCoding6_1; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc7() +{ + if (stateVars[0]!=64) + { + return stateCoding7_1; + } + if (stateVars[0]==64) + { + return stateCoding7_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc8() +{ + if (stateVars[0]!=64) + { + return stateCoding8_1; + } + if (stateVars[0]==64) + { + return stateCoding8_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc9() +{ + if (true) + { + return stateCoding9_1; + } + return stateCoding_eot; } x64Parser::StateFuncDispatchType x64Parser::stateFuncs[] = { - nullptr, - &x64Parser::StateFunc1, - &x64Parser::StateFunc2, - &x64Parser::StateFunc3, - &x64Parser::StateFunc4, - &x64Parser::StateFunc5, - &x64Parser::StateFunc6, - &x64Parser::StateFunc7, - &x64Parser::StateFunc8, - &x64Parser::StateFunc9, + nullptr, + &x64Parser::StateFunc1, + &x64Parser::StateFunc2, + &x64Parser::StateFunc3, + &x64Parser::StateFunc4, + &x64Parser::StateFunc5, + &x64Parser::StateFunc6, + &x64Parser::StateFunc7, + &x64Parser::StateFunc8, + &x64Parser::StateFunc9, }; bool x64Parser::Number1(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 1, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 1, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number2(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 1, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 1, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number3(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 6, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 6, 1, tokenPos); + } + return rv; } bool x64Parser::Number4(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number5(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number6(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number7(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(0, 0, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(0, 0, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number8(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 32) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==32) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number9(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 64) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==64) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number10(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(1, 1, 8, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(1, 1, 8, 0, tokenPos); + } + return rv; } bool x64Parser::Number11(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(-1, 1, 8, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(-1, 1, 8, 0, tokenPos); + } + return rv; } bool x64Parser::Number12(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number13(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(-2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(-2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number14(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number15(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(-2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(-2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number16(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] != 16) - { - rv = ParseNumber(4, 1, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]!=16) + { + rv = ParseNumber(4, 1, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number17(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 1, 0); - if (!rv) - rv = SetNumber(tokenPos, 2, 1); - if (!rv) - rv = SetNumber(tokenPos, 4, 2); - if (!rv) - rv = SetNumber(tokenPos, 8, 3); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 1, 0); + if (!rv) + rv = SetNumber(tokenPos, 2, 1); + if (!rv) + rv = SetNumber(tokenPos, 4, 2); + if (!rv) + rv = SetNumber(tokenPos, 8, 3); + return rv; } bool x64Parser::Number18(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 0, 0); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 0, 0); + return rv; } bool x64Parser::Number19(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 1, 1); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 1, 1); + return rv; } bool x64Parser::Number20(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 2, 2); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 2, 2); + return rv; } bool x64Parser::Number21(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 4, 4); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 4, 4); + return rv; } bool x64Parser::Number22(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 8, 8); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 8, 8); + return rv; } x64Parser::NumberDispatchType x64Parser::numberFuncs[] = { - &x64Parser::Number1, &x64Parser::Number2, &x64Parser::Number3, &x64Parser::Number4, &x64Parser::Number5, - &x64Parser::Number6, &x64Parser::Number7, &x64Parser::Number8, &x64Parser::Number9, &x64Parser::Number10, - &x64Parser::Number11, &x64Parser::Number12, &x64Parser::Number13, &x64Parser::Number14, &x64Parser::Number15, - &x64Parser::Number16, &x64Parser::Number17, &x64Parser::Number18, &x64Parser::Number19, &x64Parser::Number20, - &x64Parser::Number21, &x64Parser::Number22, + &x64Parser::Number1, + &x64Parser::Number2, + &x64Parser::Number3, + &x64Parser::Number4, + &x64Parser::Number5, + &x64Parser::Number6, + &x64Parser::Number7, + &x64Parser::Number8, + &x64Parser::Number9, + &x64Parser::Number10, + &x64Parser::Number11, + &x64Parser::Number12, + &x64Parser::Number13, + &x64Parser::Number14, + &x64Parser::Number15, + &x64Parser::Number16, + &x64Parser::Number17, + &x64Parser::Number18, + &x64Parser::Number19, + &x64Parser::Number20, + &x64Parser::Number21, + &x64Parser::Number22, }; -unsigned char x64Parser::RegClassData1[] = { - 255, - 15, - 0, - 0, -}; -unsigned char x64Parser::RegClassData2[] = { - 127, - 0, - 0, - 0, -}; -unsigned char x64Parser::RegClassData3[] = { - 190, - 15, - 0, - 0, -}; -unsigned char x64Parser::RegClassData4[] = { - 63, - 7, - 0, - 0, -}; -unsigned char x64Parser::RegClassData5[] = { - 191, - 12, - 0, - 0, -}; -unsigned char x64Parser::RegClassData6[] = { - 4, - 16, - 0, - 0, -}; -unsigned char x64Parser::RegClassData7[] = { - 8, - 96, - 0, - 0, -}; -unsigned char x64Parser::RegClassData8[] = { - 8, - 224, - 0, - 0, -}; -unsigned char x64Parser::RegClassData9[] = { - 16, - 0, - 3, - 0, -}; -unsigned char x64Parser::RegClassData10[] = { - 32, - 0, - 12, - 0, -}; -unsigned char x64Parser::RegClassData11[] = { - 128, - 0, - 48, - 0, -}; -unsigned char x64Parser::RegClassData12[] = { - 0, - 1, - 192, - 1, -}; -unsigned char x64Parser::RegClassData13[] = { - 0, - 2, - 0, - 14, -}; +unsigned char x64Parser::RegClassData1[] = {255, 15, 0, 0, }; +unsigned char x64Parser::RegClassData2[] = {127, 0, 0, 0, }; +unsigned char x64Parser::RegClassData3[] = {190, 15, 0, 0, }; +unsigned char x64Parser::RegClassData4[] = {63, 7, 0, 0, }; +unsigned char x64Parser::RegClassData5[] = {191, 12, 0, 0, }; +unsigned char x64Parser::RegClassData6[] = {4, 16, 0, 0, }; +unsigned char x64Parser::RegClassData7[] = {8, 96, 0, 0, }; +unsigned char x64Parser::RegClassData8[] = {8, 224, 0, 0, }; +unsigned char x64Parser::RegClassData9[] = {16, 0, 3, 0, }; +unsigned char x64Parser::RegClassData10[] = {32, 0, 12, 0, }; +unsigned char x64Parser::RegClassData11[] = {128, 0, 48, 0, }; +unsigned char x64Parser::RegClassData12[] = {0, 1, 192, 1, }; +unsigned char x64Parser::RegClassData13[] = {0, 2, 0, 14, }; -unsigned char x64Parser::registerData17[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData13[] = { - 0, 0, 0, 32, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData6[] = { - 136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData9[] = { - 16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData22[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, -}; -unsigned char x64Parser::registerData23[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, -}; -unsigned char x64Parser::registerData21[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, 0, -}; -unsigned char x64Parser::registerData1[] = { - 255, 255, 255, 255, 15, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData4[] = { - 2, 4, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData16[] = { - 0, 0, 0, 0, 0, 0, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData7[] = { - 136, 16, 33, 66, 4, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData10[] = { - 16, 33, 66, 132, 8, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData3[] = { - 33, 66, 132, 8, 17, 17, 17, 17, 1, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData12[] = { - 0, 0, 0, 120, 0, 0, 96, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData5[] = { - 68, 136, 16, 33, 34, 34, 34, 34, 2, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData8[] = { - 136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData11[] = { - 16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData2[] = { - 35, 70, 140, 24, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData15[] = { - 0, 0, 0, 0, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData19[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 32, 73, 146, 4, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData18[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 224, 255, 255, 31, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData20[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 7, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData14[] = { - 0, 0, 0, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData24[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, -}; +unsigned char x64Parser::registerData17[] = {0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData13[] = {0, 0, 0, 32, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData6[] = {136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData9[] = {16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData22[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, }; +unsigned char x64Parser::registerData23[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, }; +unsigned char x64Parser::registerData21[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, 0, }; +unsigned char x64Parser::registerData1[] = {255, 255, 255, 255, 15, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData4[] = {2, 4, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData16[] = {0, 0, 0, 0, 0, 0, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData7[] = {136, 16, 33, 66, 4, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData10[] = {16, 33, 66, 132, 8, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData3[] = {33, 66, 132, 8, 17, 17, 17, 17, 1, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData12[] = {0, 0, 0, 120, 0, 0, 96, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData5[] = {68, 136, 16, 33, 34, 34, 34, 34, 2, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData8[] = {136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData11[] = {16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData2[] = {35, 70, 140, 24, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData15[] = {0, 0, 0, 0, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData19[] = {0, 0, 0, 0, 0, 0, 0, 0, 32, 73, 146, 4, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData18[] = {0, 0, 0, 0, 0, 0, 0, 0, 224, 255, 255, 31, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData20[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 7, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData14[] = {0, 0, 0, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData24[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, }; -unsigned char* x64Parser::registerDataIndirect[] = { - registerData1, registerData2, registerData3, registerData4, registerData5, registerData6, registerData7, registerData8, - registerData9, registerData10, registerData11, registerData12, registerData13, registerData14, registerData15, registerData16, - registerData17, registerData18, registerData19, registerData20, registerData21, registerData22, registerData23, registerData24, +unsigned char *x64Parser::registerDataIndirect[] = { + registerData1, + registerData2, + registerData3, + registerData4, + registerData5, + registerData6, + registerData7, + registerData8, + registerData9, + registerData10, + registerData11, + registerData12, + registerData13, + registerData14, + registerData15, + registerData16, + registerData17, + registerData18, + registerData19, + registerData20, + registerData21, + registerData22, + registerData23, + registerData24, }; int x64Parser::registerValues[][8] = { - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - 0, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - 1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - 0, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - 1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - 38, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - 46, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - 54, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - 62, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - 100, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - 101, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 8, 0, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 8, 2, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 8, 0, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 8, 2, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 8, 0, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 8, 2, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 0, 0, 0, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 8, 0, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 8, 2, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 8, 0, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 8, 2, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, 1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 8, 0, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 8, 2, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, 0, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 8, 0, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 8, 2, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, 1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 8, 0, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 8, 2, -1, -1, -1, }, + { -1, -1, -1, -1, -1, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, 38, }, + { -1, 1, -1, -1, -1, -1, -1, 46, }, + { -1, 2, -1, -1, -1, -1, -1, 54, }, + { -1, 3, -1, -1, -1, -1, -1, 62, }, + { -1, 4, -1, -1, -1, -1, -1, 100, }, + { -1, 5, -1, -1, -1, -1, -1, 101, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, }; void x64Parser::Init() { - bits.SetBigEndian(IsBigEndian()); - memset(&stateVars, 0, sizeof(stateVars)); - stateVars[0] = 16; - tokenTable[""] = 0; - tokenTable["*"] = 5; - tokenTable["+"] = 4; - tokenTable[","] = 7; - tokenTable[":"] = 3; - tokenTable["["] = 1; - tokenTable["]"] = 2; - tokenTable["byte"] = 11; - tokenTable["dword"] = 9; - tokenTable["far"] = 15; - tokenTable["near"] = 14; - tokenTable["qword"] = 10; - tokenTable["short"] = 13; - tokenTable["tword"] = 12; - tokenTable["word"] = 8; - tokenTable["al"] = 1000; - tokenTable["ah"] = 1001; - tokenTable["ax"] = 1002; - tokenTable["eax"] = 1003; - tokenTable["rax"] = 1004; - tokenTable["r8b"] = 1005; - tokenTable["r8w"] = 1006; - tokenTable["r8d"] = 1007; - tokenTable["r8"] = 1008; - tokenTable["cl"] = 1009; - tokenTable["ch"] = 1010; - tokenTable["cx"] = 1011; - tokenTable["ecx"] = 1012; - tokenTable["rcx"] = 1013; - tokenTable["r9b"] = 1014; - tokenTable["r9w"] = 1015; - tokenTable["r9d"] = 1016; - tokenTable["r9"] = 1017; - tokenTable["dl"] = 1018; - tokenTable["dh"] = 1019; - tokenTable["dx"] = 1020; - tokenTable["edx"] = 1021; - tokenTable["rdx"] = 1022; - tokenTable["r10b"] = 1023; - tokenTable["r10w"] = 1024; - tokenTable["r10d"] = 1025; - tokenTable["r10"] = 1026; - tokenTable["bl"] = 1027; - tokenTable["bh"] = 1028; - tokenTable["bx"] = 1029; - tokenTable["ebx"] = 1030; - tokenTable["rbx"] = 1031; - tokenTable["r11b"] = 1032; - tokenTable["r11w"] = 1033; - tokenTable["r11d"] = 1034; - tokenTable["r11"] = 1035; - tokenTable["spl"] = 1036; - tokenTable["sp"] = 1037; - tokenTable["esp"] = 1038; - tokenTable["rsp"] = 1039; - tokenTable["r12b"] = 1040; - tokenTable["r12w"] = 1041; - tokenTable["r12d"] = 1042; - tokenTable["r12"] = 1043; - tokenTable["bpl"] = 1044; - tokenTable["bp"] = 1045; - tokenTable["ebp"] = 1046; - tokenTable["rbp"] = 1047; - tokenTable["r13b"] = 1048; - tokenTable["r13w"] = 1049; - tokenTable["r13d"] = 1050; - tokenTable["r13"] = 1051; - tokenTable["sil"] = 1052; - tokenTable["si"] = 1053; - tokenTable["esi"] = 1054; - tokenTable["rsi"] = 1055; - tokenTable["r14b"] = 1056; - tokenTable["r14w"] = 1057; - tokenTable["r14d"] = 1058; - tokenTable["r14"] = 1059; - tokenTable["dil"] = 1060; - tokenTable["di"] = 1061; - tokenTable["edi"] = 1062; - tokenTable["rdi"] = 1063; - tokenTable["r15b"] = 1064; - tokenTable["r15w"] = 1065; - tokenTable["r15d"] = 1066; - tokenTable["r15"] = 1067; - tokenTable["rip"] = 1068; - tokenTable["mm0"] = 1069; - tokenTable["xmm0"] = 1070; - tokenTable["xmm8"] = 1071; - tokenTable["mm1"] = 1072; - tokenTable["xmm1"] = 1073; - tokenTable["xmm9"] = 1074; - tokenTable["mm2"] = 1075; - tokenTable["xmm2"] = 1076; - tokenTable["xmm10"] = 1077; - tokenTable["mm3"] = 1078; - tokenTable["xmm3"] = 1079; - tokenTable["xmm11"] = 1080; - tokenTable["mm4"] = 1081; - tokenTable["xmm4"] = 1082; - tokenTable["xmm12"] = 1083; - tokenTable["mm5"] = 1084; - tokenTable["xmm5"] = 1085; - tokenTable["xmm13"] = 1086; - tokenTable["mm6"] = 1087; - tokenTable["xmm6"] = 1088; - tokenTable["xmm14"] = 1089; - tokenTable["mm7"] = 1090; - tokenTable["xmm7"] = 1091; - tokenTable["xmm15"] = 1092; - tokenTable["es"] = 1093; - tokenTable["cs"] = 1094; - tokenTable["ss"] = 1095; - tokenTable["ds"] = 1096; - tokenTable["fs"] = 1097; - tokenTable["gs"] = 1098; - tokenTable["st0"] = 1099; - tokenTable["st1"] = 1100; - tokenTable["st2"] = 1101; - tokenTable["st3"] = 1102; - tokenTable["st4"] = 1103; - tokenTable["st5"] = 1104; - tokenTable["st6"] = 1105; - tokenTable["st7"] = 1106; - tokenTable["cr0"] = 1107; - tokenTable["cr1"] = 1108; - tokenTable["cr2"] = 1109; - tokenTable["cr3"] = 1110; - tokenTable["cr4"] = 1111; - tokenTable["cr5"] = 1112; - tokenTable["cr6"] = 1113; - tokenTable["cr7"] = 1114; - tokenTable["dr0"] = 1115; - tokenTable["dr1"] = 1116; - tokenTable["dr2"] = 1117; - tokenTable["dr3"] = 1118; - tokenTable["dr4"] = 1119; - tokenTable["dr5"] = 1120; - tokenTable["dr6"] = 1121; - tokenTable["dr7"] = 1122; - tokenTable["tr0"] = 1123; - tokenTable["tr1"] = 1124; - tokenTable["tr2"] = 1125; - tokenTable["tr3"] = 1126; - tokenTable["tr4"] = 1127; - tokenTable["tr5"] = 1128; - tokenTable["tr6"] = 1129; - tokenTable["tr7"] = 1130; - opcodeTable["aaa"] = 32; - opcodeTable["aad"] = 33; - opcodeTable["aam"] = 34; - opcodeTable["aas"] = 35; - opcodeTable["adc"] = 36; - opcodeTable["add"] = 37; - opcodeTable["and"] = 38; - opcodeTable["arpl"] = 39; - opcodeTable["bound"] = 40; - opcodeTable["bsf"] = 41; - opcodeTable["bsr"] = 42; - opcodeTable["bswap"] = 43; - opcodeTable["bt"] = 44; - opcodeTable["btc"] = 45; - opcodeTable["btr"] = 46; - opcodeTable["bts"] = 47; - opcodeTable["call"] = 48; - opcodeTable["cbw"] = 49; - opcodeTable["cdq"] = 50; - opcodeTable["cdqe"] = 51; - opcodeTable["clc"] = 52; - opcodeTable["cld"] = 53; - opcodeTable["cli"] = 54; - opcodeTable["clts"] = 55; - opcodeTable["cmc"] = 56; - opcodeTable["cmova"] = 57; - opcodeTable["cmovae"] = 58; - opcodeTable["cmovb"] = 59; - opcodeTable["cmovbe"] = 60; - opcodeTable["cmovc"] = 61; - opcodeTable["cmove"] = 62; - opcodeTable["cmovg"] = 63; - opcodeTable["cmovge"] = 64; - opcodeTable["cmovl"] = 65; - opcodeTable["cmovle"] = 66; - opcodeTable["cmovna"] = 67; - opcodeTable["cmovnae"] = 68; - opcodeTable["cmovnb"] = 69; - opcodeTable["cmovnbe"] = 70; - opcodeTable["cmovnc"] = 71; - opcodeTable["cmovne"] = 72; - opcodeTable["cmovng"] = 73; - opcodeTable["cmovnge"] = 74; - opcodeTable["cmovnl"] = 75; - opcodeTable["cmovnle"] = 76; - opcodeTable["cmovno"] = 77; - opcodeTable["cmovnp"] = 78; - opcodeTable["cmovns"] = 79; - opcodeTable["cmovnz"] = 80; - opcodeTable["cmovo"] = 81; - opcodeTable["cmovp"] = 82; - opcodeTable["cmovpe"] = 83; - opcodeTable["cmovpo"] = 84; - opcodeTable["cmovs"] = 85; - opcodeTable["cmovz"] = 86; - opcodeTable["cmp"] = 87; - opcodeTable["cmps"] = 88; - opcodeTable["cmpsb"] = 89; - opcodeTable["cmpsw"] = 90; - opcodeTable["cmpsd"] = 91; - opcodeTable["cmpsq"] = 92; - opcodeTable["cmpxchg"] = 93; - opcodeTable["cmpxchg8b"] = 94; - opcodeTable["cmpxchg16b"] = 95; - opcodeTable["cpuid"] = 96; - opcodeTable["cqo"] = 97; - opcodeTable["cwd"] = 98; - opcodeTable["cwde"] = 99; - opcodeTable["daa"] = 100; - opcodeTable["das"] = 101; - opcodeTable["dec"] = 102; - opcodeTable["div"] = 103; - opcodeTable["enter"] = 104; - opcodeTable["esc"] = 105; - opcodeTable["f2xm1"] = 106; - opcodeTable["fabs"] = 107; - opcodeTable["fadd"] = 108; - opcodeTable["faddp"] = 109; - opcodeTable["fbld"] = 110; - opcodeTable["fbstp"] = 111; - opcodeTable["fchs"] = 112; - opcodeTable["fclex"] = 113; - opcodeTable["fnclex"] = 114; - opcodeTable["fcmovb"] = 115; - opcodeTable["fcmovbe"] = 116; - opcodeTable["fcmove"] = 117; - opcodeTable["fcmovnb"] = 118; - opcodeTable["fcmovnbe"] = 119; - opcodeTable["fcmovne"] = 120; - opcodeTable["fcmovnu"] = 121; - opcodeTable["fcmovu"] = 122; - opcodeTable["fcom"] = 123; - opcodeTable["fcomi"] = 124; - opcodeTable["fcomip"] = 125; - opcodeTable["fcomp"] = 126; - opcodeTable["fcompp"] = 127; - opcodeTable["fcos"] = 128; - opcodeTable["fdecstp"] = 129; - opcodeTable["fdisi"] = 130; - opcodeTable["fdiv"] = 131; - opcodeTable["fdivp"] = 132; - opcodeTable["fdivr"] = 133; - opcodeTable["fdivrp"] = 134; - opcodeTable["feni"] = 135; - opcodeTable["ffree"] = 136; - opcodeTable["ffreep"] = 137; - opcodeTable["fiadd"] = 138; - opcodeTable["ficom"] = 139; - opcodeTable["ficomp"] = 140; - opcodeTable["fidiv"] = 141; - opcodeTable["fidivr"] = 142; - opcodeTable["fild"] = 143; - opcodeTable["fimul"] = 144; - opcodeTable["fincstp"] = 145; - opcodeTable["finit"] = 146; - opcodeTable["fninit"] = 147; - opcodeTable["fist"] = 148; - opcodeTable["fistp"] = 149; - opcodeTable["fisub"] = 150; - opcodeTable["fisubr"] = 151; - opcodeTable["fld"] = 152; - opcodeTable["fld1"] = 153; - opcodeTable["fldcw"] = 154; - opcodeTable["fldenv"] = 155; - opcodeTable["fldl2e"] = 156; - opcodeTable["fldl2t"] = 157; - opcodeTable["fldlg2"] = 158; - opcodeTable["fldln2"] = 159; - opcodeTable["fldpi"] = 160; - opcodeTable["fldz"] = 161; - opcodeTable["fmul"] = 162; - opcodeTable["fmulp"] = 163; - opcodeTable["fnop"] = 164; - opcodeTable["fnsave"] = 165; - opcodeTable["fpatan"] = 166; - opcodeTable["fprem"] = 167; - opcodeTable["fprem1"] = 168; - opcodeTable["fptan"] = 169; - opcodeTable["frndint"] = 170; - opcodeTable["frstor"] = 171; - opcodeTable["fsave"] = 172; - opcodeTable["fscale"] = 173; - opcodeTable["fsetpm"] = 174; - opcodeTable["fsin"] = 175; - opcodeTable["fsincos"] = 176; - opcodeTable["fsqrt"] = 177; - opcodeTable["fst"] = 178; - opcodeTable["fstcw"] = 179; - opcodeTable["fnstcw"] = 180; - opcodeTable["fstenv"] = 181; - opcodeTable["fnstenv"] = 182; - opcodeTable["fstp"] = 183; - opcodeTable["fstsw"] = 184; - opcodeTable["fnstsw"] = 185; - opcodeTable["fsub"] = 186; - opcodeTable["fsubp"] = 187; - opcodeTable["fsubr"] = 188; - opcodeTable["fsubrp"] = 189; - opcodeTable["ftst"] = 190; - opcodeTable["fucom"] = 191; - opcodeTable["fucomi"] = 192; - opcodeTable["fucomip"] = 193; - opcodeTable["fucomp"] = 194; - opcodeTable["fucompp"] = 195; - opcodeTable["fwait"] = 196; - opcodeTable["fxam"] = 197; - opcodeTable["fxch"] = 198; - opcodeTable["fxch4"] = 199; - opcodeTable["fxch7"] = 200; - opcodeTable["fxrstor"] = 201; - opcodeTable["fxsave"] = 202; - opcodeTable["fxtract"] = 203; - opcodeTable["fyl2x"] = 204; - opcodeTable["fyl2xp1"] = 205; - opcodeTable["hlt"] = 206; - opcodeTable["icebp"] = 207; - opcodeTable["idiv"] = 208; - opcodeTable["imul"] = 209; - opcodeTable["in"] = 210; - opcodeTable["ins"] = 211; - opcodeTable["insb"] = 212; - opcodeTable["insw"] = 213; - opcodeTable["insd"] = 214; - opcodeTable["inc"] = 215; - opcodeTable["int"] = 216; - opcodeTable["int1"] = 217; - opcodeTable["int3"] = 218; - opcodeTable["into"] = 219; - opcodeTable["invd"] = 220; - opcodeTable["invlpg"] = 221; - opcodeTable["iret"] = 222; - opcodeTable["iretw"] = 223; - opcodeTable["iretd"] = 224; - opcodeTable["iretq"] = 225; - opcodeTable["ja"] = 226; - opcodeTable["jae"] = 227; - opcodeTable["jb"] = 228; - opcodeTable["jbe"] = 229; - opcodeTable["jc"] = 230; - opcodeTable["jcxz"] = 231; - opcodeTable["jecxz"] = 232; - opcodeTable["je"] = 233; - opcodeTable["jg"] = 234; - opcodeTable["jge"] = 235; - opcodeTable["jl"] = 236; - opcodeTable["jle"] = 237; - opcodeTable["jmp"] = 238; - opcodeTable["jna"] = 239; - opcodeTable["jnae"] = 240; - opcodeTable["jnb"] = 241; - opcodeTable["jnbe"] = 242; - opcodeTable["jnc"] = 243; - opcodeTable["jne"] = 244; - opcodeTable["jng"] = 245; - opcodeTable["jnge"] = 246; - opcodeTable["jnl"] = 247; - opcodeTable["jnle"] = 248; - opcodeTable["jno"] = 249; - opcodeTable["jnp"] = 250; - opcodeTable["jns"] = 251; - opcodeTable["jnz"] = 252; - opcodeTable["jo"] = 253; - opcodeTable["jp"] = 254; - opcodeTable["jpe"] = 255; - opcodeTable["jpo"] = 256; - opcodeTable["js"] = 257; - opcodeTable["jz"] = 258; - opcodeTable["lahf"] = 259; - opcodeTable["lar"] = 260; - opcodeTable["lds"] = 261; - opcodeTable["lea"] = 262; - opcodeTable["leave"] = 263; - opcodeTable["les"] = 264; - opcodeTable["lfence"] = 265; - opcodeTable["lfs"] = 266; - opcodeTable["lgdt"] = 267; - opcodeTable["lgs"] = 268; - opcodeTable["lidt"] = 269; - opcodeTable["lldt"] = 270; - opcodeTable["lmsw"] = 271; - opcodeTable["lods"] = 272; - opcodeTable["lodsb"] = 273; - opcodeTable["lodsw"] = 274; - opcodeTable["lodsd"] = 275; - opcodeTable["lodsq"] = 276; - opcodeTable["loop"] = 277; - opcodeTable["loope"] = 278; - opcodeTable["loopne"] = 279; - opcodeTable["loopnz"] = 280; - opcodeTable["loopz"] = 281; - opcodeTable["lsl"] = 282; - opcodeTable["lss"] = 283; - opcodeTable["ltr"] = 284; - opcodeTable["mov"] = 285; - opcodeTable["movs"] = 286; - opcodeTable["movbe"] = 287; - opcodeTable["movsb"] = 288; - opcodeTable["movsw"] = 289; - opcodeTable["movsd"] = 290; - opcodeTable["movsq"] = 291; - opcodeTable["movsx"] = 292; - opcodeTable["movzx"] = 293; - opcodeTable["movsxd"] = 294; - opcodeTable["mul"] = 295; - opcodeTable["neg"] = 296; - opcodeTable["nop"] = 297; - opcodeTable["not"] = 298; - opcodeTable["or"] = 299; - opcodeTable["out"] = 300; - opcodeTable["outs"] = 301; - opcodeTable["outsb"] = 302; - opcodeTable["outsw"] = 303; - opcodeTable["outsd"] = 304; - opcodeTable["pop"] = 305; - opcodeTable["popa"] = 306; - opcodeTable["popaw"] = 307; - opcodeTable["popad"] = 308; - opcodeTable["popcnt"] = 309; - opcodeTable["popf"] = 310; - opcodeTable["popfw"] = 311; - opcodeTable["popfd"] = 312; - opcodeTable["popfq"] = 313; - opcodeTable["prefetchnta"] = 314; - opcodeTable["prefetcht0"] = 315; - opcodeTable["prefetcht1"] = 316; - opcodeTable["prefetcht2"] = 317; - opcodeTable["push"] = 318; - opcodeTable["pusha"] = 319; - opcodeTable["pushaw"] = 320; - opcodeTable["pushad"] = 321; - opcodeTable["pushf"] = 322; - opcodeTable["pushfw"] = 323; - opcodeTable["pushfd"] = 324; - opcodeTable["pushfq"] = 325; - opcodeTable["rcl"] = 326; - opcodeTable["rcr"] = 327; - opcodeTable["rdmsr"] = 328; - opcodeTable["rdpmc"] = 329; - opcodeTable["rdtsc"] = 330; - opcodeTable["ret"] = 331; - opcodeTable["retf"] = 332; - opcodeTable["rol"] = 333; - opcodeTable["ror"] = 334; - opcodeTable["rsm"] = 335; - opcodeTable["sahf"] = 336; - opcodeTable["sal"] = 337; - opcodeTable["sar"] = 338; - opcodeTable["sbb"] = 339; - opcodeTable["scas"] = 340; - opcodeTable["scasb"] = 341; - opcodeTable["scasw"] = 342; - opcodeTable["scasd"] = 343; - opcodeTable["scasq"] = 344; - opcodeTable["seta"] = 345; - opcodeTable["setae"] = 346; - opcodeTable["setb"] = 347; - opcodeTable["setbe"] = 348; - opcodeTable["setc"] = 349; - opcodeTable["sete"] = 350; - opcodeTable["setg"] = 351; - opcodeTable["setge"] = 352; - opcodeTable["setl"] = 353; - opcodeTable["setle"] = 354; - opcodeTable["setna"] = 355; - opcodeTable["setnae"] = 356; - opcodeTable["setnb"] = 357; - opcodeTable["setnbe"] = 358; - opcodeTable["setnc"] = 359; - opcodeTable["setne"] = 360; - opcodeTable["setng"] = 361; - opcodeTable["setnge"] = 362; - opcodeTable["setnl"] = 363; - opcodeTable["setnle"] = 364; - opcodeTable["setno"] = 365; - opcodeTable["setnp"] = 366; - opcodeTable["setns"] = 367; - opcodeTable["setnz"] = 368; - opcodeTable["seto"] = 369; - opcodeTable["setp"] = 370; - opcodeTable["setpe"] = 371; - opcodeTable["setpo"] = 372; - opcodeTable["sets"] = 373; - opcodeTable["setz"] = 374; - opcodeTable["sfence"] = 375; - opcodeTable["sgdt"] = 376; - opcodeTable["shl"] = 377; - opcodeTable["shld"] = 378; - opcodeTable["shr"] = 379; - opcodeTable["shrd"] = 380; - opcodeTable["sidt"] = 381; - opcodeTable["sldt"] = 382; - opcodeTable["smsw"] = 383; - opcodeTable["stc"] = 384; - opcodeTable["std"] = 385; - opcodeTable["sti"] = 386; - opcodeTable["stos"] = 387; - opcodeTable["stosb"] = 388; - opcodeTable["stosw"] = 389; - opcodeTable["stosd"] = 390; - opcodeTable["stosq"] = 391; - opcodeTable["str"] = 392; - opcodeTable["sub"] = 393; - opcodeTable["syscall"] = 394; - opcodeTable["sysenter"] = 395; - opcodeTable["sysexit"] = 396; - opcodeTable["sysret"] = 397; - opcodeTable["test"] = 398; - opcodeTable["ud2"] = 399; - opcodeTable["verr"] = 400; - opcodeTable["verw"] = 401; - opcodeTable["wait"] = 402; - opcodeTable["wbinvd"] = 403; - opcodeTable["wrmsr"] = 404; - opcodeTable["xadd"] = 405; - opcodeTable["xchg"] = 406; - opcodeTable["xlat"] = 407; - opcodeTable["xlatb"] = 408; - opcodeTable["xor"] = 409; - opcodeTable["xrstor"] = 410; - opcodeTable["xrstor64"] = 411; - opcodeTable["xsave"] = 412; - opcodeTable["xsave64"] = 413; - opcodeTable["xsetbv"] = 414; - opcodeTable["addpd"] = 415; - opcodeTable["addps"] = 416; - opcodeTable["addsd"] = 417; - opcodeTable["addss"] = 418; - opcodeTable["addsubpd"] = 419; - opcodeTable["addsubps"] = 420; - opcodeTable["andnpd"] = 421; - opcodeTable["andnps"] = 422; - opcodeTable["andpd"] = 423; - opcodeTable["andps"] = 424; - opcodeTable["blendpd"] = 425; - opcodeTable["blendps"] = 426; - opcodeTable["cmppd"] = 427; - opcodeTable["cmpps"] = 428; - opcodeTable["comisd"] = 429; - opcodeTable["comiss"] = 430; - opcodeTable["cvtdq2pd"] = 431; - opcodeTable["cvtdq2ps"] = 432; - opcodeTable["cvtpd2dq"] = 433; - opcodeTable["cvtpd2pi"] = 434; - opcodeTable["cvtpd2ps"] = 435; - opcodeTable["cvtpi2pd"] = 436; - opcodeTable["cvtpi2ps"] = 437; - opcodeTable["cvtps2dq"] = 438; - opcodeTable["cvtps2pd"] = 439; - opcodeTable["cvtps2pi"] = 440; - opcodeTable["cvtsd2si"] = 441; - opcodeTable["cvtsd2ss"] = 442; - opcodeTable["cvtsi2sd"] = 443; - opcodeTable["cvtsi2ss"] = 444; - opcodeTable["cvtss2sd"] = 445; - opcodeTable["cvtss2si"] = 446; - opcodeTable["cvttpd2dq"] = 447; - opcodeTable["cvttpd2pi"] = 448; - opcodeTable["cvttps2dq"] = 449; - opcodeTable["cvttps2pi"] = 450; - opcodeTable["cvttsd2si"] = 451; - opcodeTable["cvttss2si"] = 452; - opcodeTable["divpd"] = 453; - opcodeTable["divps"] = 454; - opcodeTable["divsd"] = 455; - opcodeTable["divss"] = 456; - opcodeTable["dppd"] = 457; - opcodeTable["dpps"] = 458; - opcodeTable["hsubpd"] = 459; - opcodeTable["hsubps"] = 460; - opcodeTable["insertps"] = 461; - opcodeTable["lddqu"] = 462; - opcodeTable["maskmovdqu"] = 463; - opcodeTable["maskmovq"] = 464; - opcodeTable["maxpd"] = 465; - opcodeTable["maxps"] = 466; - opcodeTable["maxsd"] = 467; - opcodeTable["maxss"] = 468; - opcodeTable["mfence"] = 469; - opcodeTable["pause"] = 470; - opcodeTable["minpd"] = 471; - opcodeTable["minps"] = 472; - opcodeTable["minsd"] = 473; - opcodeTable["minss"] = 474; - opcodeTable["monitor"] = 475; - opcodeTable["movapd"] = 476; - opcodeTable["movaps"] = 477; - opcodeTable["movd"] = 478; - opcodeTable["movq"] = 479; - opcodeTable["movddup"] = 480; - opcodeTable["movdq2q"] = 481; - opcodeTable["movdqa"] = 482; - opcodeTable["movdqu"] = 483; - opcodeTable["movhlps"] = 484; - opcodeTable["movhpd"] = 485; - opcodeTable["movhps"] = 486; - opcodeTable["movlhps"] = 487; - opcodeTable["movlpd"] = 488; - opcodeTable["movlps"] = 489; - opcodeTable["movmskpd"] = 490; - opcodeTable["movmskps"] = 491; - opcodeTable["movntdq"] = 492; - opcodeTable["movnti"] = 493; - opcodeTable["movntpd"] = 494; - opcodeTable["movntd"] = 495; - opcodeTable["movntq"] = 496; - opcodeTable["movq2dq"] = 497; - opcodeTable["movshdup"] = 498; - opcodeTable["movsldup"] = 499; - opcodeTable["movss"] = 500; - opcodeTable["movupd"] = 501; - opcodeTable["movups"] = 502; - opcodeTable["mpsadbw"] = 503; - opcodeTable["mulpd"] = 504; - opcodeTable["mulps"] = 505; - opcodeTable["mulsd"] = 506; - opcodeTable["mulss"] = 507; - opcodeTable["orpd"] = 508; - opcodeTable["orps"] = 509; - opcodeTable["packssdw"] = 510; - opcodeTable["packsswb"] = 511; - opcodeTable["packusdw"] = 512; - opcodeTable["paddb"] = 513; - opcodeTable["paddd"] = 514; - opcodeTable["paddq"] = 515; - opcodeTable["paddsw"] = 516; - opcodeTable["paddusb"] = 517; - opcodeTable["paddusw"] = 518; - opcodeTable["paddw"] = 519; - opcodeTable["palignr"] = 520; - opcodeTable["pand"] = 521; - opcodeTable["pandn"] = 522; - opcodeTable["pavgb"] = 523; - opcodeTable["pavgw"] = 524; - opcodeTable["pblendw"] = 525; - opcodeTable["pcmpeqb"] = 526; - opcodeTable["pcmpeqd"] = 527; - opcodeTable["pcmpeqw"] = 528; - opcodeTable["pcmpestri"] = 529; - opcodeTable["pcmpestrm"] = 530; - opcodeTable["pcmpgtb"] = 531; - opcodeTable["pcmpgtd"] = 532; - opcodeTable["pcmpgtw"] = 533; - opcodeTable["pextrb"] = 534; - opcodeTable["pextrd"] = 535; - opcodeTable["pextrq"] = 536; - opcodeTable["pextrw"] = 537; - opcodeTable["pinsrb"] = 538; - opcodeTable["pinsrd"] = 539; - opcodeTable["pinsrq"] = 540; - opcodeTable["pinsrw"] = 541; - opcodeTable["pmaddwd"] = 542; - opcodeTable["pmaxsw"] = 543; - opcodeTable["pmaxub"] = 544; - opcodeTable["pminsw"] = 545; - opcodeTable["pminub"] = 546; - opcodeTable["pmovmskb"] = 547; - opcodeTable["pmulhuw"] = 548; - opcodeTable["pmulhw"] = 549; - opcodeTable["pmullw"] = 550; - opcodeTable["pmuludq"] = 551; - opcodeTable["psadbw"] = 552; - opcodeTable["pshufd"] = 553; - opcodeTable["pshufhw"] = 554; - opcodeTable["pshuflw"] = 555; - opcodeTable["pshufw"] = 556; - opcodeTable["pslld"] = 557; - opcodeTable["pslldq"] = 558; - opcodeTable["psllq"] = 559; - opcodeTable["psllw"] = 560; - opcodeTable["psrad"] = 561; - opcodeTable["psraw"] = 562; - opcodeTable["psrld"] = 563; - opcodeTable["psrldq"] = 564; - opcodeTable["psrlq"] = 565; - opcodeTable["psrlw"] = 566; - opcodeTable["psubb"] = 567; - opcodeTable["psubd"] = 568; - opcodeTable["psubq"] = 569; - opcodeTable["psubsb"] = 570; - opcodeTable["psubsw"] = 571; - opcodeTable["psubusb"] = 572; - opcodeTable["psubusw"] = 573; - opcodeTable["punpckhbw"] = 574; - opcodeTable["punpckhdq"] = 575; - opcodeTable["punpckhqdq"] = 576; - opcodeTable["punpckhwd"] = 577; - opcodeTable["punpcklbw"] = 578; - opcodeTable["punpckldq"] = 579; - opcodeTable["punpcklqdq"] = 580; - opcodeTable["punpcklwd"] = 581; - opcodeTable["pxor"] = 582; - opcodeTable["rcpps"] = 583; - opcodeTable["rcpss"] = 584; - opcodeTable["roundpd"] = 585; - opcodeTable["roundps"] = 586; - opcodeTable["roundsd"] = 587; - opcodeTable["roundss"] = 588; - opcodeTable["rsqrtps"] = 589; - opcodeTable["rsqrtss"] = 590; - opcodeTable["shufpd"] = 591; - opcodeTable["shufps"] = 592; - opcodeTable["sqrtpd"] = 593; - opcodeTable["sqrtps"] = 594; - opcodeTable["sqrtsd"] = 595; - opcodeTable["sqrtss"] = 596; - opcodeTable["subpd"] = 597; - opcodeTable["subps"] = 598; - opcodeTable["subsd"] = 599; - opcodeTable["subss"] = 600; - opcodeTable["ucomisd"] = 601; - opcodeTable["ucomiss"] = 602; - opcodeTable["unpckhpd"] = 603; - opcodeTable["unpckhps"] = 604; - opcodeTable["unpcklpd"] = 605; - opcodeTable["unpcklps"] = 606; - opcodeTable["xorpd"] = 607; - opcodeTable["xorps"] = 608; - opcodeTable["invept"] = 609; - opcodeTable["invvpid"] = 610; - opcodeTable["vmcall"] = 611; - opcodeTable["vmclear"] = 612; - opcodeTable["vmlaunch"] = 613; - opcodeTable["vmptrld"] = 614; - opcodeTable["vmptrst"] = 615; - opcodeTable["vmread"] = 616; - opcodeTable["vmresume"] = 617; - opcodeTable["vmwrite"] = 618; - opcodeTable["vmxoff"] = 619; - opcodeTable["vmxon"] = 620; - prefixTable["a16"] = 0; - prefixTable["a32"] = 1; - prefixTable["lock"] = 2; - prefixTable["o16"] = 3; - prefixTable["o32"] = 4; - prefixTable["rep"] = 5; - prefixTable["repe"] = 6; - prefixTable["repne"] = 7; - prefixTable["repnz"] = 8; - prefixTable["repz"] = 9; + bits.SetBigEndian(IsBigEndian()); + memset(&stateVars, 0, sizeof(stateVars)); + stateVars[0] = 16; + tokenTable[""] = 0; + tokenTable["*"] = 5; + tokenTable["+"] = 4; + tokenTable[","] = 7; + tokenTable[":"] = 3; + tokenTable["["] = 1; + tokenTable["]"] = 2; + tokenTable["byte"] = 11; + tokenTable["dword"] = 9; + tokenTable["far"] = 15; + tokenTable["near"] = 14; + tokenTable["qword"] = 10; + tokenTable["short"] = 13; + tokenTable["tword"] = 12; + tokenTable["word"] = 8; + tokenTable["al"] = 1000; + tokenTable["ah"] = 1001; + tokenTable["ax"] = 1002; + tokenTable["eax"] = 1003; + tokenTable["rax"] = 1004; + tokenTable["r8b"] = 1005; + tokenTable["r8w"] = 1006; + tokenTable["r8d"] = 1007; + tokenTable["r8"] = 1008; + tokenTable["cl"] = 1009; + tokenTable["ch"] = 1010; + tokenTable["cx"] = 1011; + tokenTable["ecx"] = 1012; + tokenTable["rcx"] = 1013; + tokenTable["r9b"] = 1014; + tokenTable["r9w"] = 1015; + tokenTable["r9d"] = 1016; + tokenTable["r9"] = 1017; + tokenTable["dl"] = 1018; + tokenTable["dh"] = 1019; + tokenTable["dx"] = 1020; + tokenTable["edx"] = 1021; + tokenTable["rdx"] = 1022; + tokenTable["r10b"] = 1023; + tokenTable["r10w"] = 1024; + tokenTable["r10d"] = 1025; + tokenTable["r10"] = 1026; + tokenTable["bl"] = 1027; + tokenTable["bh"] = 1028; + tokenTable["bx"] = 1029; + tokenTable["ebx"] = 1030; + tokenTable["rbx"] = 1031; + tokenTable["r11b"] = 1032; + tokenTable["r11w"] = 1033; + tokenTable["r11d"] = 1034; + tokenTable["r11"] = 1035; + tokenTable["spl"] = 1036; + tokenTable["sp"] = 1037; + tokenTable["esp"] = 1038; + tokenTable["rsp"] = 1039; + tokenTable["r12b"] = 1040; + tokenTable["r12w"] = 1041; + tokenTable["r12d"] = 1042; + tokenTable["r12"] = 1043; + tokenTable["bpl"] = 1044; + tokenTable["bp"] = 1045; + tokenTable["ebp"] = 1046; + tokenTable["rbp"] = 1047; + tokenTable["r13b"] = 1048; + tokenTable["r13w"] = 1049; + tokenTable["r13d"] = 1050; + tokenTable["r13"] = 1051; + tokenTable["sil"] = 1052; + tokenTable["si"] = 1053; + tokenTable["esi"] = 1054; + tokenTable["rsi"] = 1055; + tokenTable["r14b"] = 1056; + tokenTable["r14w"] = 1057; + tokenTable["r14d"] = 1058; + tokenTable["r14"] = 1059; + tokenTable["dil"] = 1060; + tokenTable["di"] = 1061; + tokenTable["edi"] = 1062; + tokenTable["rdi"] = 1063; + tokenTable["r15b"] = 1064; + tokenTable["r15w"] = 1065; + tokenTable["r15d"] = 1066; + tokenTable["r15"] = 1067; + tokenTable["rip"] = 1068; + tokenTable["mm0"] = 1069; + tokenTable["xmm0"] = 1070; + tokenTable["xmm8"] = 1071; + tokenTable["mm1"] = 1072; + tokenTable["xmm1"] = 1073; + tokenTable["xmm9"] = 1074; + tokenTable["mm2"] = 1075; + tokenTable["xmm2"] = 1076; + tokenTable["xmm10"] = 1077; + tokenTable["mm3"] = 1078; + tokenTable["xmm3"] = 1079; + tokenTable["xmm11"] = 1080; + tokenTable["mm4"] = 1081; + tokenTable["xmm4"] = 1082; + tokenTable["xmm12"] = 1083; + tokenTable["mm5"] = 1084; + tokenTable["xmm5"] = 1085; + tokenTable["xmm13"] = 1086; + tokenTable["mm6"] = 1087; + tokenTable["xmm6"] = 1088; + tokenTable["xmm14"] = 1089; + tokenTable["mm7"] = 1090; + tokenTable["xmm7"] = 1091; + tokenTable["xmm15"] = 1092; + tokenTable["es"] = 1093; + tokenTable["cs"] = 1094; + tokenTable["ss"] = 1095; + tokenTable["ds"] = 1096; + tokenTable["fs"] = 1097; + tokenTable["gs"] = 1098; + tokenTable["st0"] = 1099; + tokenTable["st1"] = 1100; + tokenTable["st2"] = 1101; + tokenTable["st3"] = 1102; + tokenTable["st4"] = 1103; + tokenTable["st5"] = 1104; + tokenTable["st6"] = 1105; + tokenTable["st7"] = 1106; + tokenTable["cr0"] = 1107; + tokenTable["cr1"] = 1108; + tokenTable["cr2"] = 1109; + tokenTable["cr3"] = 1110; + tokenTable["cr4"] = 1111; + tokenTable["cr5"] = 1112; + tokenTable["cr6"] = 1113; + tokenTable["cr7"] = 1114; + tokenTable["dr0"] = 1115; + tokenTable["dr1"] = 1116; + tokenTable["dr2"] = 1117; + tokenTable["dr3"] = 1118; + tokenTable["dr4"] = 1119; + tokenTable["dr5"] = 1120; + tokenTable["dr6"] = 1121; + tokenTable["dr7"] = 1122; + tokenTable["tr0"] = 1123; + tokenTable["tr1"] = 1124; + tokenTable["tr2"] = 1125; + tokenTable["tr3"] = 1126; + tokenTable["tr4"] = 1127; + tokenTable["tr5"] = 1128; + tokenTable["tr6"] = 1129; + tokenTable["tr7"] = 1130; + opcodeTable["aaa"] = 32; + opcodeTable["aad"] = 33; + opcodeTable["aam"] = 34; + opcodeTable["aas"] = 35; + opcodeTable["adc"] = 36; + opcodeTable["add"] = 37; + opcodeTable["and"] = 38; + opcodeTable["arpl"] = 39; + opcodeTable["bound"] = 40; + opcodeTable["bsf"] = 41; + opcodeTable["bsr"] = 42; + opcodeTable["bswap"] = 43; + opcodeTable["bt"] = 44; + opcodeTable["btc"] = 45; + opcodeTable["btr"] = 46; + opcodeTable["bts"] = 47; + opcodeTable["call"] = 48; + opcodeTable["cbw"] = 49; + opcodeTable["cdq"] = 50; + opcodeTable["cdqe"] = 51; + opcodeTable["clc"] = 52; + opcodeTable["cld"] = 53; + opcodeTable["cli"] = 54; + opcodeTable["clts"] = 55; + opcodeTable["cmc"] = 56; + opcodeTable["cmova"] = 57; + opcodeTable["cmovae"] = 58; + opcodeTable["cmovb"] = 59; + opcodeTable["cmovbe"] = 60; + opcodeTable["cmovc"] = 61; + opcodeTable["cmove"] = 62; + opcodeTable["cmovg"] = 63; + opcodeTable["cmovge"] = 64; + opcodeTable["cmovl"] = 65; + opcodeTable["cmovle"] = 66; + opcodeTable["cmovna"] = 67; + opcodeTable["cmovnae"] = 68; + opcodeTable["cmovnb"] = 69; + opcodeTable["cmovnbe"] = 70; + opcodeTable["cmovnc"] = 71; + opcodeTable["cmovne"] = 72; + opcodeTable["cmovng"] = 73; + opcodeTable["cmovnge"] = 74; + opcodeTable["cmovnl"] = 75; + opcodeTable["cmovnle"] = 76; + opcodeTable["cmovno"] = 77; + opcodeTable["cmovnp"] = 78; + opcodeTable["cmovns"] = 79; + opcodeTable["cmovnz"] = 80; + opcodeTable["cmovo"] = 81; + opcodeTable["cmovp"] = 82; + opcodeTable["cmovpe"] = 83; + opcodeTable["cmovpo"] = 84; + opcodeTable["cmovs"] = 85; + opcodeTable["cmovz"] = 86; + opcodeTable["cmp"] = 87; + opcodeTable["cmps"] = 88; + opcodeTable["cmpsb"] = 89; + opcodeTable["cmpsw"] = 90; + opcodeTable["cmpsd"] = 91; + opcodeTable["cmpsq"] = 92; + opcodeTable["cmpxchg"] = 93; + opcodeTable["cmpxchg8b"] = 94; + opcodeTable["cmpxchg16b"] = 95; + opcodeTable["cpuid"] = 96; + opcodeTable["cqo"] = 97; + opcodeTable["cwd"] = 98; + opcodeTable["cwde"] = 99; + opcodeTable["daa"] = 100; + opcodeTable["das"] = 101; + opcodeTable["dec"] = 102; + opcodeTable["div"] = 103; + opcodeTable["enter"] = 104; + opcodeTable["esc"] = 105; + opcodeTable["f2xm1"] = 106; + opcodeTable["fabs"] = 107; + opcodeTable["fadd"] = 108; + opcodeTable["faddp"] = 109; + opcodeTable["fbld"] = 110; + opcodeTable["fbstp"] = 111; + opcodeTable["fchs"] = 112; + opcodeTable["fclex"] = 113; + opcodeTable["fnclex"] = 114; + opcodeTable["fcmovb"] = 115; + opcodeTable["fcmovbe"] = 116; + opcodeTable["fcmove"] = 117; + opcodeTable["fcmovnb"] = 118; + opcodeTable["fcmovnbe"] = 119; + opcodeTable["fcmovne"] = 120; + opcodeTable["fcmovnu"] = 121; + opcodeTable["fcmovu"] = 122; + opcodeTable["fcom"] = 123; + opcodeTable["fcomi"] = 124; + opcodeTable["fcomip"] = 125; + opcodeTable["fcomp"] = 126; + opcodeTable["fcompp"] = 127; + opcodeTable["fcos"] = 128; + opcodeTable["fdecstp"] = 129; + opcodeTable["fdisi"] = 130; + opcodeTable["fdiv"] = 131; + opcodeTable["fdivp"] = 132; + opcodeTable["fdivr"] = 133; + opcodeTable["fdivrp"] = 134; + opcodeTable["feni"] = 135; + opcodeTable["ffree"] = 136; + opcodeTable["ffreep"] = 137; + opcodeTable["fiadd"] = 138; + opcodeTable["ficom"] = 139; + opcodeTable["ficomp"] = 140; + opcodeTable["fidiv"] = 141; + opcodeTable["fidivr"] = 142; + opcodeTable["fild"] = 143; + opcodeTable["fimul"] = 144; + opcodeTable["fincstp"] = 145; + opcodeTable["finit"] = 146; + opcodeTable["fninit"] = 147; + opcodeTable["fist"] = 148; + opcodeTable["fistp"] = 149; + opcodeTable["fisub"] = 150; + opcodeTable["fisubr"] = 151; + opcodeTable["fld"] = 152; + opcodeTable["fld1"] = 153; + opcodeTable["fldcw"] = 154; + opcodeTable["fldenv"] = 155; + opcodeTable["fldl2e"] = 156; + opcodeTable["fldl2t"] = 157; + opcodeTable["fldlg2"] = 158; + opcodeTable["fldln2"] = 159; + opcodeTable["fldpi"] = 160; + opcodeTable["fldz"] = 161; + opcodeTable["fmul"] = 162; + opcodeTable["fmulp"] = 163; + opcodeTable["fnop"] = 164; + opcodeTable["fnsave"] = 165; + opcodeTable["fpatan"] = 166; + opcodeTable["fprem"] = 167; + opcodeTable["fprem1"] = 168; + opcodeTable["fptan"] = 169; + opcodeTable["frndint"] = 170; + opcodeTable["frstor"] = 171; + opcodeTable["fsave"] = 172; + opcodeTable["fscale"] = 173; + opcodeTable["fsetpm"] = 174; + opcodeTable["fsin"] = 175; + opcodeTable["fsincos"] = 176; + opcodeTable["fsqrt"] = 177; + opcodeTable["fst"] = 178; + opcodeTable["fstcw"] = 179; + opcodeTable["fnstcw"] = 180; + opcodeTable["fstenv"] = 181; + opcodeTable["fnstenv"] = 182; + opcodeTable["fstp"] = 183; + opcodeTable["fstsw"] = 184; + opcodeTable["fnstsw"] = 185; + opcodeTable["fsub"] = 186; + opcodeTable["fsubp"] = 187; + opcodeTable["fsubr"] = 188; + opcodeTable["fsubrp"] = 189; + opcodeTable["ftst"] = 190; + opcodeTable["fucom"] = 191; + opcodeTable["fucomi"] = 192; + opcodeTable["fucomip"] = 193; + opcodeTable["fucomp"] = 194; + opcodeTable["fucompp"] = 195; + opcodeTable["fwait"] = 196; + opcodeTable["fxam"] = 197; + opcodeTable["fxch"] = 198; + opcodeTable["fxch4"] = 199; + opcodeTable["fxch7"] = 200; + opcodeTable["fxrstor"] = 201; + opcodeTable["fxsave"] = 202; + opcodeTable["fxtract"] = 203; + opcodeTable["fyl2x"] = 204; + opcodeTable["fyl2xp1"] = 205; + opcodeTable["hlt"] = 206; + opcodeTable["icebp"] = 207; + opcodeTable["idiv"] = 208; + opcodeTable["imul"] = 209; + opcodeTable["in"] = 210; + opcodeTable["ins"] = 211; + opcodeTable["insb"] = 212; + opcodeTable["insw"] = 213; + opcodeTable["insd"] = 214; + opcodeTable["inc"] = 215; + opcodeTable["int"] = 216; + opcodeTable["int1"] = 217; + opcodeTable["int3"] = 218; + opcodeTable["into"] = 219; + opcodeTable["invd"] = 220; + opcodeTable["invlpg"] = 221; + opcodeTable["iret"] = 222; + opcodeTable["iretw"] = 223; + opcodeTable["iretd"] = 224; + opcodeTable["iretq"] = 225; + opcodeTable["ja"] = 226; + opcodeTable["jae"] = 227; + opcodeTable["jb"] = 228; + opcodeTable["jbe"] = 229; + opcodeTable["jc"] = 230; + opcodeTable["jcxz"] = 231; + opcodeTable["jecxz"] = 232; + opcodeTable["je"] = 233; + opcodeTable["jg"] = 234; + opcodeTable["jge"] = 235; + opcodeTable["jl"] = 236; + opcodeTable["jle"] = 237; + opcodeTable["jmp"] = 238; + opcodeTable["jna"] = 239; + opcodeTable["jnae"] = 240; + opcodeTable["jnb"] = 241; + opcodeTable["jnbe"] = 242; + opcodeTable["jnc"] = 243; + opcodeTable["jne"] = 244; + opcodeTable["jng"] = 245; + opcodeTable["jnge"] = 246; + opcodeTable["jnl"] = 247; + opcodeTable["jnle"] = 248; + opcodeTable["jno"] = 249; + opcodeTable["jnp"] = 250; + opcodeTable["jns"] = 251; + opcodeTable["jnz"] = 252; + opcodeTable["jo"] = 253; + opcodeTable["jp"] = 254; + opcodeTable["jpe"] = 255; + opcodeTable["jpo"] = 256; + opcodeTable["js"] = 257; + opcodeTable["jz"] = 258; + opcodeTable["lahf"] = 259; + opcodeTable["lar"] = 260; + opcodeTable["lds"] = 261; + opcodeTable["lea"] = 262; + opcodeTable["leave"] = 263; + opcodeTable["les"] = 264; + opcodeTable["lfence"] = 265; + opcodeTable["lfs"] = 266; + opcodeTable["lgdt"] = 267; + opcodeTable["lgs"] = 268; + opcodeTable["lidt"] = 269; + opcodeTable["lldt"] = 270; + opcodeTable["lmsw"] = 271; + opcodeTable["lods"] = 272; + opcodeTable["lodsb"] = 273; + opcodeTable["lodsw"] = 274; + opcodeTable["lodsd"] = 275; + opcodeTable["lodsq"] = 276; + opcodeTable["loop"] = 277; + opcodeTable["loope"] = 278; + opcodeTable["loopne"] = 279; + opcodeTable["loopnz"] = 280; + opcodeTable["loopz"] = 281; + opcodeTable["lsl"] = 282; + opcodeTable["lss"] = 283; + opcodeTable["ltr"] = 284; + opcodeTable["mov"] = 285; + opcodeTable["movs"] = 286; + opcodeTable["movbe"] = 287; + opcodeTable["movsb"] = 288; + opcodeTable["movsw"] = 289; + opcodeTable["movsd"] = 290; + opcodeTable["movsq"] = 291; + opcodeTable["movsx"] = 292; + opcodeTable["movzx"] = 293; + opcodeTable["movsxd"] = 294; + opcodeTable["mul"] = 295; + opcodeTable["neg"] = 296; + opcodeTable["nop"] = 297; + opcodeTable["not"] = 298; + opcodeTable["or"] = 299; + opcodeTable["out"] = 300; + opcodeTable["outs"] = 301; + opcodeTable["outsb"] = 302; + opcodeTable["outsw"] = 303; + opcodeTable["outsd"] = 304; + opcodeTable["pop"] = 305; + opcodeTable["popa"] = 306; + opcodeTable["popaw"] = 307; + opcodeTable["popad"] = 308; + opcodeTable["popcnt"] = 309; + opcodeTable["popf"] = 310; + opcodeTable["popfw"] = 311; + opcodeTable["popfd"] = 312; + opcodeTable["popfq"] = 313; + opcodeTable["prefetchnta"] = 314; + opcodeTable["prefetcht0"] = 315; + opcodeTable["prefetcht1"] = 316; + opcodeTable["prefetcht2"] = 317; + opcodeTable["push"] = 318; + opcodeTable["pusha"] = 319; + opcodeTable["pushaw"] = 320; + opcodeTable["pushad"] = 321; + opcodeTable["pushf"] = 322; + opcodeTable["pushfw"] = 323; + opcodeTable["pushfd"] = 324; + opcodeTable["pushfq"] = 325; + opcodeTable["rcl"] = 326; + opcodeTable["rcr"] = 327; + opcodeTable["rdmsr"] = 328; + opcodeTable["rdpmc"] = 329; + opcodeTable["rdtsc"] = 330; + opcodeTable["ret"] = 331; + opcodeTable["retf"] = 332; + opcodeTable["rol"] = 333; + opcodeTable["ror"] = 334; + opcodeTable["rsm"] = 335; + opcodeTable["sahf"] = 336; + opcodeTable["sal"] = 337; + opcodeTable["sar"] = 338; + opcodeTable["sbb"] = 339; + opcodeTable["scas"] = 340; + opcodeTable["scasb"] = 341; + opcodeTable["scasw"] = 342; + opcodeTable["scasd"] = 343; + opcodeTable["scasq"] = 344; + opcodeTable["seta"] = 345; + opcodeTable["setae"] = 346; + opcodeTable["setb"] = 347; + opcodeTable["setbe"] = 348; + opcodeTable["setc"] = 349; + opcodeTable["sete"] = 350; + opcodeTable["setg"] = 351; + opcodeTable["setge"] = 352; + opcodeTable["setl"] = 353; + opcodeTable["setle"] = 354; + opcodeTable["setna"] = 355; + opcodeTable["setnae"] = 356; + opcodeTable["setnb"] = 357; + opcodeTable["setnbe"] = 358; + opcodeTable["setnc"] = 359; + opcodeTable["setne"] = 360; + opcodeTable["setng"] = 361; + opcodeTable["setnge"] = 362; + opcodeTable["setnl"] = 363; + opcodeTable["setnle"] = 364; + opcodeTable["setno"] = 365; + opcodeTable["setnp"] = 366; + opcodeTable["setns"] = 367; + opcodeTable["setnz"] = 368; + opcodeTable["seto"] = 369; + opcodeTable["setp"] = 370; + opcodeTable["setpe"] = 371; + opcodeTable["setpo"] = 372; + opcodeTable["sets"] = 373; + opcodeTable["setz"] = 374; + opcodeTable["sfence"] = 375; + opcodeTable["sgdt"] = 376; + opcodeTable["shl"] = 377; + opcodeTable["shld"] = 378; + opcodeTable["shr"] = 379; + opcodeTable["shrd"] = 380; + opcodeTable["sidt"] = 381; + opcodeTable["sldt"] = 382; + opcodeTable["smsw"] = 383; + opcodeTable["stc"] = 384; + opcodeTable["std"] = 385; + opcodeTable["sti"] = 386; + opcodeTable["stos"] = 387; + opcodeTable["stosb"] = 388; + opcodeTable["stosw"] = 389; + opcodeTable["stosd"] = 390; + opcodeTable["stosq"] = 391; + opcodeTable["str"] = 392; + opcodeTable["sub"] = 393; + opcodeTable["syscall"] = 394; + opcodeTable["sysenter"] = 395; + opcodeTable["sysexit"] = 396; + opcodeTable["sysret"] = 397; + opcodeTable["test"] = 398; + opcodeTable["ud2"] = 399; + opcodeTable["verr"] = 400; + opcodeTable["verw"] = 401; + opcodeTable["wait"] = 402; + opcodeTable["wbinvd"] = 403; + opcodeTable["wrmsr"] = 404; + opcodeTable["xadd"] = 405; + opcodeTable["xchg"] = 406; + opcodeTable["xlat"] = 407; + opcodeTable["xlatb"] = 408; + opcodeTable["xor"] = 409; + opcodeTable["xrstor"] = 410; + opcodeTable["xrstor64"] = 411; + opcodeTable["xsave"] = 412; + opcodeTable["xsave64"] = 413; + opcodeTable["xsetbv"] = 414; + opcodeTable["addpd"] = 415; + opcodeTable["addps"] = 416; + opcodeTable["addsd"] = 417; + opcodeTable["addss"] = 418; + opcodeTable["addsubpd"] = 419; + opcodeTable["addsubps"] = 420; + opcodeTable["andnpd"] = 421; + opcodeTable["andnps"] = 422; + opcodeTable["andpd"] = 423; + opcodeTable["andps"] = 424; + opcodeTable["blendpd"] = 425; + opcodeTable["blendps"] = 426; + opcodeTable["cmppd"] = 427; + opcodeTable["cmpps"] = 428; + opcodeTable["comisd"] = 429; + opcodeTable["comiss"] = 430; + opcodeTable["cvtdq2pd"] = 431; + opcodeTable["cvtdq2ps"] = 432; + opcodeTable["cvtpd2dq"] = 433; + opcodeTable["cvtpd2pi"] = 434; + opcodeTable["cvtpd2ps"] = 435; + opcodeTable["cvtpi2pd"] = 436; + opcodeTable["cvtpi2ps"] = 437; + opcodeTable["cvtps2dq"] = 438; + opcodeTable["cvtps2pd"] = 439; + opcodeTable["cvtps2pi"] = 440; + opcodeTable["cvtsd2si"] = 441; + opcodeTable["cvtsd2ss"] = 442; + opcodeTable["cvtsi2sd"] = 443; + opcodeTable["cvtsi2ss"] = 444; + opcodeTable["cvtss2sd"] = 445; + opcodeTable["cvtss2si"] = 446; + opcodeTable["cvttpd2dq"] = 447; + opcodeTable["cvttpd2pi"] = 448; + opcodeTable["cvttps2dq"] = 449; + opcodeTable["cvttps2pi"] = 450; + opcodeTable["cvttsd2si"] = 451; + opcodeTable["cvttss2si"] = 452; + opcodeTable["divpd"] = 453; + opcodeTable["divps"] = 454; + opcodeTable["divsd"] = 455; + opcodeTable["divss"] = 456; + opcodeTable["dppd"] = 457; + opcodeTable["dpps"] = 458; + opcodeTable["hsubpd"] = 459; + opcodeTable["hsubps"] = 460; + opcodeTable["insertps"] = 461; + opcodeTable["lddqu"] = 462; + opcodeTable["maskmovdqu"] = 463; + opcodeTable["maskmovq"] = 464; + opcodeTable["maxpd"] = 465; + opcodeTable["maxps"] = 466; + opcodeTable["maxsd"] = 467; + opcodeTable["maxss"] = 468; + opcodeTable["mfence"] = 469; + opcodeTable["pause"] = 470; + opcodeTable["minpd"] = 471; + opcodeTable["minps"] = 472; + opcodeTable["minsd"] = 473; + opcodeTable["minss"] = 474; + opcodeTable["monitor"] = 475; + opcodeTable["movapd"] = 476; + opcodeTable["movaps"] = 477; + opcodeTable["movd"] = 478; + opcodeTable["movq"] = 479; + opcodeTable["movddup"] = 480; + opcodeTable["movdq2q"] = 481; + opcodeTable["movdqa"] = 482; + opcodeTable["movdqu"] = 483; + opcodeTable["movhlps"] = 484; + opcodeTable["movhpd"] = 485; + opcodeTable["movhps"] = 486; + opcodeTable["movlhps"] = 487; + opcodeTable["movlpd"] = 488; + opcodeTable["movlps"] = 489; + opcodeTable["movmskpd"] = 490; + opcodeTable["movmskps"] = 491; + opcodeTable["movntdq"] = 492; + opcodeTable["movnti"] = 493; + opcodeTable["movntpd"] = 494; + opcodeTable["movntd"] = 495; + opcodeTable["movntq"] = 496; + opcodeTable["movq2dq"] = 497; + opcodeTable["movshdup"] = 498; + opcodeTable["movsldup"] = 499; + opcodeTable["movss"] = 500; + opcodeTable["movupd"] = 501; + opcodeTable["movups"] = 502; + opcodeTable["mpsadbw"] = 503; + opcodeTable["mulpd"] = 504; + opcodeTable["mulps"] = 505; + opcodeTable["mulsd"] = 506; + opcodeTable["mulss"] = 507; + opcodeTable["orpd"] = 508; + opcodeTable["orps"] = 509; + opcodeTable["packssdw"] = 510; + opcodeTable["packsswb"] = 511; + opcodeTable["packusdw"] = 512; + opcodeTable["paddb"] = 513; + opcodeTable["paddd"] = 514; + opcodeTable["paddq"] = 515; + opcodeTable["paddsw"] = 516; + opcodeTable["paddusb"] = 517; + opcodeTable["paddusw"] = 518; + opcodeTable["paddw"] = 519; + opcodeTable["palignr"] = 520; + opcodeTable["pand"] = 521; + opcodeTable["pandn"] = 522; + opcodeTable["pavgb"] = 523; + opcodeTable["pavgw"] = 524; + opcodeTable["pblendw"] = 525; + opcodeTable["pcmpeqb"] = 526; + opcodeTable["pcmpeqd"] = 527; + opcodeTable["pcmpeqw"] = 528; + opcodeTable["pcmpestri"] = 529; + opcodeTable["pcmpestrm"] = 530; + opcodeTable["pcmpgtb"] = 531; + opcodeTable["pcmpgtd"] = 532; + opcodeTable["pcmpgtw"] = 533; + opcodeTable["pextrb"] = 534; + opcodeTable["pextrd"] = 535; + opcodeTable["pextrq"] = 536; + opcodeTable["pextrw"] = 537; + opcodeTable["pinsrb"] = 538; + opcodeTable["pinsrd"] = 539; + opcodeTable["pinsrq"] = 540; + opcodeTable["pinsrw"] = 541; + opcodeTable["pmaddwd"] = 542; + opcodeTable["pmaxsw"] = 543; + opcodeTable["pmaxub"] = 544; + opcodeTable["pminsw"] = 545; + opcodeTable["pminub"] = 546; + opcodeTable["pmovmskb"] = 547; + opcodeTable["pmulhuw"] = 548; + opcodeTable["pmulhw"] = 549; + opcodeTable["pmullw"] = 550; + opcodeTable["pmuludq"] = 551; + opcodeTable["psadbw"] = 552; + opcodeTable["pshufd"] = 553; + opcodeTable["pshufhw"] = 554; + opcodeTable["pshuflw"] = 555; + opcodeTable["pshufw"] = 556; + opcodeTable["pslld"] = 557; + opcodeTable["pslldq"] = 558; + opcodeTable["psllq"] = 559; + opcodeTable["psllw"] = 560; + opcodeTable["psrad"] = 561; + opcodeTable["psraw"] = 562; + opcodeTable["psrld"] = 563; + opcodeTable["psrldq"] = 564; + opcodeTable["psrlq"] = 565; + opcodeTable["psrlw"] = 566; + opcodeTable["psubb"] = 567; + opcodeTable["psubd"] = 568; + opcodeTable["psubq"] = 569; + opcodeTable["psubsb"] = 570; + opcodeTable["psubsw"] = 571; + opcodeTable["psubusb"] = 572; + opcodeTable["psubusw"] = 573; + opcodeTable["punpckhbw"] = 574; + opcodeTable["punpckhdq"] = 575; + opcodeTable["punpckhqdq"] = 576; + opcodeTable["punpckhwd"] = 577; + opcodeTable["punpcklbw"] = 578; + opcodeTable["punpckldq"] = 579; + opcodeTable["punpcklqdq"] = 580; + opcodeTable["punpcklwd"] = 581; + opcodeTable["pxor"] = 582; + opcodeTable["rcpps"] = 583; + opcodeTable["rcpss"] = 584; + opcodeTable["roundpd"] = 585; + opcodeTable["roundps"] = 586; + opcodeTable["roundsd"] = 587; + opcodeTable["roundss"] = 588; + opcodeTable["rsqrtps"] = 589; + opcodeTable["rsqrtss"] = 590; + opcodeTable["shufpd"] = 591; + opcodeTable["shufps"] = 592; + opcodeTable["sqrtpd"] = 593; + opcodeTable["sqrtps"] = 594; + opcodeTable["sqrtsd"] = 595; + opcodeTable["sqrtss"] = 596; + opcodeTable["subpd"] = 597; + opcodeTable["subps"] = 598; + opcodeTable["subsd"] = 599; + opcodeTable["subss"] = 600; + opcodeTable["ucomisd"] = 601; + opcodeTable["ucomiss"] = 602; + opcodeTable["unpckhpd"] = 603; + opcodeTable["unpckhps"] = 604; + opcodeTable["unpcklpd"] = 605; + opcodeTable["unpcklps"] = 606; + opcodeTable["xorpd"] = 607; + opcodeTable["xorps"] = 608; + opcodeTable["invept"] = 609; + opcodeTable["invvpid"] = 610; + opcodeTable["vmcall"] = 611; + opcodeTable["vmclear"] = 612; + opcodeTable["vmlaunch"] = 613; + opcodeTable["vmptrld"] = 614; + opcodeTable["vmptrst"] = 615; + opcodeTable["vmread"] = 616; + opcodeTable["vmresume"] = 617; + opcodeTable["vmwrite"] = 618; + opcodeTable["vmxoff"] = 619; + opcodeTable["vmxon"] = 620; + prefixTable["a16"] = 0; + prefixTable["a32"] = 1; + prefixTable["lock"] = 2; + prefixTable["o16"] = 3; + prefixTable["o32"] = 4; + prefixTable["rep"] = 5; + prefixTable["repe"] = 6; + prefixTable["repne"] = 7; + prefixTable["repnz"] = 8; + prefixTable["repz"] = 9; } -void x64Parser::TokenFunc4(x64Operand& operand, int tokenPos) { operand.addressCoding = 0; } -x64Token x64Parser::tokenBranches3[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc4, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc9(x64Operand& operand, int tokenPos) { operand.addressCoding = 1; } -x64Token x64Parser::tokenBranches8[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc9, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc200(x64Operand& operand, int tokenPos) { operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches199[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc200, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc346(x64Operand& operand, int tokenPos) { operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc199(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc345(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 0; } -x64Token x64Parser::tokenBranches198[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc199, x64Parser::tokenBranches199}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc345, x64Parser::tokenBranches345}, - {x64Token::EOT}}; -void x64Parser::TokenFunc36(x64Operand& operand, int tokenPos) { operand.addressCoding = 4; } -x64Token x64Parser::tokenBranches35[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc36, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc137(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc283(x64Operand& operand, int tokenPos) { operand.addressCoding = 28; } -x64Token x64Parser::tokenBranches282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc429(x64Operand& operand, int tokenPos) { operand.addressCoding = 43; } -x64Token x64Parser::tokenBranches428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc35(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc136(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc282(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc428(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc4, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc9(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 1; } -x64Token x64Parser::tokenBranches34[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc35, x64Parser::tokenBranches35}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc136, x64Parser::tokenBranches136}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc282, x64Parser::tokenBranches282}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc428, x64Parser::tokenBranches428}, - {x64Token::EOT}}; -void x64Parser::TokenFunc97(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches33[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches34}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc97, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc227(x64Operand& operand, int tokenPos) { operand.addressCoding = 22; } -x64Token x64Parser::tokenBranches226[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc227, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc373(x64Operand& operand, int tokenPos) { operand.addressCoding = 37; } -x64Token x64Parser::tokenBranches372[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc373, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc226(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc372(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches8[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc9, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc200(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches225[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc226, x64Parser::tokenBranches226}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc372, x64Parser::tokenBranches372}, - {x64Token::EOT}}; -void x64Parser::TokenFunc57(x64Operand& operand, int tokenPos) { operand.addressCoding = 7; } -x64Token x64Parser::tokenBranches56[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc57, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches225}, - {x64Token::EOT}}; -void x64Parser::TokenFunc170(x64Operand& operand, int tokenPos) { operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc316(x64Operand& operand, int tokenPos) { operand.addressCoding = 32; } -x64Token x64Parser::tokenBranches315[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc316, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc462(x64Operand& operand, int tokenPos) { operand.addressCoding = 47; } -x64Token x64Parser::tokenBranches461[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc462, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc56(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc169(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc315(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc461(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches199[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc200, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches55[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc56, x64Parser::tokenBranches56}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc169, x64Parser::tokenBranches169}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc315, x64Parser::tokenBranches315}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc461, x64Parser::tokenBranches461}, - {x64Token::EOT}}; -void x64Parser::TokenFunc120(x64Operand& operand, int tokenPos) { operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches54[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches55}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc120, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc257(x64Operand& operand, int tokenPos) { operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches256[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc257, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc403(x64Operand& operand, int tokenPos) { operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches402[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc403, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc256(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc402(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc199(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches255[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc256, x64Parser::tokenBranches256}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc402, x64Parser::tokenBranches402}, - {x64Token::EOT}}; -void x64Parser::TokenFunc79(x64Operand& operand, int tokenPos) { operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches78[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc79, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches255}, - {x64Token::EOT}}; -void x64Parser::TokenFunc606(x64Operand& operand, int tokenPos) { operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches605[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc606, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc702(x64Operand& operand, int tokenPos) { operand.addressCoding = 70; } -x64Token x64Parser::tokenBranches701[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc702, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc826(x64Operand& operand, int tokenPos) { operand.addressCoding = 84; } -x64Token x64Parser::tokenBranches825[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc826, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2121(x64Operand& operand, int tokenPos) { operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches2120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2121, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2680(x64Operand& operand, int tokenPos) { operand.addressCoding = 202; } -x64Token x64Parser::tokenBranches2679[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2680, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2951(x64Operand& operand, int tokenPos) { operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches2950[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2951, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2120(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2679(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2950(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc345(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2119[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2120, x64Parser::tokenBranches2120}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2679, x64Parser::tokenBranches2679}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2950, x64Parser::tokenBranches2950}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2403(x64Operand& operand, int tokenPos) { operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches2118[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2119}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2403, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2118(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches198[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc199, x64Parser::tokenBranches199 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc345, x64Parser::tokenBranches345 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc36(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 4; +} +x64Token x64Parser::tokenBranches35[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc36, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 28; +} +x64Token x64Parser::tokenBranches282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 43; +} +x64Token x64Parser::tokenBranches428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc35(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc136(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc282(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc428(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2117[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2118, x64Parser::tokenBranches2118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2130(x64Operand& operand, int tokenPos) { operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches2129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2689(x64Operand& operand, int tokenPos) { operand.addressCoding = 203; } -x64Token x64Parser::tokenBranches2688[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2689, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2960(x64Operand& operand, int tokenPos) { operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches2959[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2960, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2129(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2688(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2959(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches34[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc35, x64Parser::tokenBranches35 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc136, x64Parser::tokenBranches136 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc282, x64Parser::tokenBranches282 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc428, x64Parser::tokenBranches428 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc97(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches2128[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2129, x64Parser::tokenBranches2129}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2688, x64Parser::tokenBranches2688}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2959, x64Parser::tokenBranches2959}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2410(x64Operand& operand, int tokenPos) { operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches2116[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2117}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2128}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2410, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc605(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc701(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc825(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2116(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches33[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches34 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc97, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc227(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 22; } -x64Token x64Parser::tokenBranches604[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc605, x64Parser::tokenBranches605}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc701, x64Parser::tokenBranches701}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc825, x64Parser::tokenBranches825}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2116, x64Parser::tokenBranches2116}, - {x64Token::EOT}}; -void x64Parser::TokenFunc506(x64Operand& operand, int tokenPos) { operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches505[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc506, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches604}, - {x64Token::EOT}}; -void x64Parser::TokenFunc613(x64Operand& operand, int tokenPos) { operand.addressCoding = 67; } -x64Token x64Parser::tokenBranches612[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc613, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc709(x64Operand& operand, int tokenPos) { operand.addressCoding = 71; } -x64Token x64Parser::tokenBranches708[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc709, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc833(x64Operand& operand, int tokenPos) { operand.addressCoding = 85; } -x64Token x64Parser::tokenBranches832[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc833, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2101(x64Operand& operand, int tokenPos) { operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2100[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2101, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2660(x64Operand& operand, int tokenPos) { operand.addressCoding = 200; } -x64Token x64Parser::tokenBranches2659[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2660, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2931(x64Operand& operand, int tokenPos) { operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2930[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2931, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2100(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2659(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2930(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches226[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc227, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc373(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 37; } -x64Token x64Parser::tokenBranches2099[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2100, x64Parser::tokenBranches2100}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2659, x64Parser::tokenBranches2659}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2930, x64Parser::tokenBranches2930}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2387(x64Operand& operand, int tokenPos) { operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2098[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2099}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2098(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches372[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc373, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc226(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2097[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2098, x64Parser::tokenBranches2098}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2110(x64Operand& operand, int tokenPos) { operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2669(x64Operand& operand, int tokenPos) { operand.addressCoding = 201; } -x64Token x64Parser::tokenBranches2668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2669, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2940(x64Operand& operand, int tokenPos) { operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches2939[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2940, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2109(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2668(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2939(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc372(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2108[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2109, x64Parser::tokenBranches2109}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2668, x64Parser::tokenBranches2668}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2939, x64Parser::tokenBranches2939}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2394(x64Operand& operand, int tokenPos) { operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2096[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2097}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2108}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2394, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2219(x64Operand& operand, int tokenPos) { operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches2218[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2219, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2631(x64Operand& operand, int tokenPos) { operand.addressCoding = 198; } -x64Token x64Parser::tokenBranches2630[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2631, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3009(x64Operand& operand, int tokenPos) { operand.addressCoding = 228; } -x64Token x64Parser::tokenBranches3008[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3009, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2218(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2630(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3008(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches225[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc226, x64Parser::tokenBranches226 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc372, x64Parser::tokenBranches372 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc57(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 7; +} +x64Token x64Parser::tokenBranches56[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc57, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches225 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 17; +} +x64Token x64Parser::tokenBranches169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc316(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 32; +} +x64Token x64Parser::tokenBranches315[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc316, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc462(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 47; +} +x64Token x64Parser::tokenBranches461[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc462, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc56(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc169(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc315(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc461(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2217[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2218, x64Parser::tokenBranches2218}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2630, x64Parser::tokenBranches2630}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3008, x64Parser::tokenBranches3008}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2449(x64Operand& operand, int tokenPos) { operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches2216[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2217}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2449, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc612(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc708(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc832(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2096(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches55[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc56, x64Parser::tokenBranches56 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc169, x64Parser::tokenBranches169 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc315, x64Parser::tokenBranches315 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc461, x64Parser::tokenBranches461 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc120(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches611[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2216}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc612, x64Parser::tokenBranches612}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc708, x64Parser::tokenBranches708}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc832, x64Parser::tokenBranches832}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2096, x64Parser::tokenBranches2096}, - {x64Token::EOT}}; -void x64Parser::TokenFunc975(x64Operand& operand, int tokenPos) { operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches974[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc975, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc984(x64Operand& operand, int tokenPos) { operand.addressCoding = 100; } -x64Token x64Parser::tokenBranches983[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc984, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc993(x64Operand& operand, int tokenPos) { operand.addressCoding = 101; } -x64Token x64Parser::tokenBranches992[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc993, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc974(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc983(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc992(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches54[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches55 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc120, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc257(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches973[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc974, x64Parser::tokenBranches974}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc983, x64Parser::tokenBranches983}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc992, x64Parser::tokenBranches992}, - {x64Token::EOT}}; -void x64Parser::TokenFunc966(x64Operand& operand, int tokenPos) { operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches965[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc966, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches973}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1103(x64Operand& operand, int tokenPos) { operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1102[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1103, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1112(x64Operand& operand, int tokenPos) { operand.addressCoding = 109; } -x64Token x64Parser::tokenBranches1111[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1112, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1121(x64Operand& operand, int tokenPos) { operand.addressCoding = 110; } -x64Token x64Parser::tokenBranches1120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1121, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1102(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1111(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1120(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches256[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc257, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc403(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches1101[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1102, x64Parser::tokenBranches1102}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1111, x64Parser::tokenBranches1111}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1120, x64Parser::tokenBranches1120}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1094(x64Operand& operand, int tokenPos) { operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1093[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1094, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1101}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1480(x64Operand& operand, int tokenPos) { operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches1479[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1480, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1489(x64Operand& operand, int tokenPos) { operand.addressCoding = 135; } -x64Token x64Parser::tokenBranches1488[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1489, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1479(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1488(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches402[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc403, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc256(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1478[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1479, x64Parser::tokenBranches1479}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1488, x64Parser::tokenBranches1488}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1471(x64Operand& operand, int tokenPos) { operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches1470[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1471, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1478}, - {x64Token::EOT}}; -void x64Parser::TokenFunc965(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1093(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1470(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc402(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches964[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc965, x64Parser::tokenBranches965}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1093, x64Parser::tokenBranches1093}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1470, x64Parser::tokenBranches1470}, - {x64Token::EOT}}; -void x64Parser::TokenFunc511(x64Operand& operand, int tokenPos) { operand.addressCoding = 58; } -x64Token x64Parser::tokenBranches510[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc511, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches611}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches964}, - {x64Token::EOT}}; -void x64Parser::TokenFunc653(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches652[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc653, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc777(x64Operand& operand, int tokenPos) { operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches776[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc777, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc901(x64Operand& operand, int tokenPos) { operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc901, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc652(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc776(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc900(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches255[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc256, x64Parser::tokenBranches256 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc402, x64Parser::tokenBranches402 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc79(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches651[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc652, x64Parser::tokenBranches652}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc776, x64Parser::tokenBranches776}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc900, x64Parser::tokenBranches900}, - {x64Token::EOT}}; -void x64Parser::TokenFunc538(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches537[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc538, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches651}, - {x64Token::EOT}}; -void x64Parser::TokenFunc644(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches643[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc644, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc768(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches767[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc768, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc892(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches891[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc892, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2300(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2832(x64Operand& operand, int tokenPos) { operand.addressCoding = 214; } -x64Token x64Parser::tokenBranches2831[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2832, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3130(x64Operand& operand, int tokenPos) { operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches3129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2299(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2831(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3129(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches78[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc79, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches255 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc606(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches2298[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2299, x64Parser::tokenBranches2299}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2831, x64Parser::tokenBranches2831}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3129, x64Parser::tokenBranches3129}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2544(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2297[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2298}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2544, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2297(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches605[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc606, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc702(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 70; } -x64Token x64Parser::tokenBranches2296[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2297, x64Parser::tokenBranches2297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2309(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2308[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2309, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2841(x64Operand& operand, int tokenPos) { operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches2840[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2841, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3139(x64Operand& operand, int tokenPos) { operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches3138[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3139, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2308(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2840(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3138(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches701[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc702, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc826(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 84; } -x64Token x64Parser::tokenBranches2307[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2308, x64Parser::tokenBranches2308}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2840, x64Parser::tokenBranches2840}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3138, x64Parser::tokenBranches3138}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2551(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2295[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2296}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2307}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc643(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc767(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc891(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2295(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches825[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc826, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2121(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches536[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches537}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc643, x64Parser::tokenBranches643}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc767, x64Parser::tokenBranches767}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc891, x64Parser::tokenBranches891}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2295, x64Parser::tokenBranches2295}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1625(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1624[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1625, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1634(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches1633[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1634, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1643(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches1642[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1643, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1624(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1633(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1642(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2120[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2121, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2680(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 202; } -x64Token x64Parser::tokenBranches1623[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1624, x64Parser::tokenBranches1624}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1633, x64Parser::tokenBranches1633}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1642, x64Parser::tokenBranches1642}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1616(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1615[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1616, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1623}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1753(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1752[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1753, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1762(x64Operand& operand, int tokenPos) { operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches1761[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1762, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1771(x64Operand& operand, int tokenPos) { operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1770[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1771, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1752(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1761(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1770(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2679[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2680, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2951(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches1751[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1752, x64Parser::tokenBranches1752}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1761, x64Parser::tokenBranches1761}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1770, x64Parser::tokenBranches1770}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1744(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1743[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1744, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1751}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1899(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1898[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1899, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1908(x64Operand& operand, int tokenPos) { operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches1907[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1928(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1927[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1928, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1939(x64Operand& operand, int tokenPos) { operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches1938[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1939, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1927(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1938(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2950[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2951, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2120(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1926[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1927, x64Parser::tokenBranches1927}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1938, x64Parser::tokenBranches1938}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1917(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1917, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1926}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1898(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1907(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2679(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1897[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1916}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1898, x64Parser::tokenBranches1898}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1907, x64Parser::tokenBranches1907}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1890(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1889[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1890, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1615(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1743(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1889(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2950(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1614[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1615, x64Parser::tokenBranches1615}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1743, x64Parser::tokenBranches1743}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1889, x64Parser::tokenBranches1889}, - {x64Token::EOT}}; -void x64Parser::TokenFunc526(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches525[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc526, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches536}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1614}, - {x64Token::EOT}}; -void x64Parser::TokenFunc565(x64Operand& operand, int tokenPos) { operand.addressCoding = 64; } -x64Token x64Parser::tokenBranches564[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc565, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1231(x64Operand& operand, int tokenPos) { operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches1230[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1231, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1240(x64Operand& operand, int tokenPos) { operand.addressCoding = 118; } -x64Token x64Parser::tokenBranches1239[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1240, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1249(x64Operand& operand, int tokenPos) { operand.addressCoding = 119; } -x64Token x64Parser::tokenBranches1248[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1249, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1230(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1239(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1248(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2119[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2120, x64Parser::tokenBranches2120 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2679, x64Parser::tokenBranches2679 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2950, x64Parser::tokenBranches2950 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2403(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches1229[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1230, x64Parser::tokenBranches1230}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1239, x64Parser::tokenBranches1239}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1248, x64Parser::tokenBranches1248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1222(x64Operand& operand, int tokenPos) { operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches1221[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1222, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1229}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1359(x64Operand& operand, int tokenPos) { operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches1358[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1359, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1368(x64Operand& operand, int tokenPos) { operand.addressCoding = 127; } -x64Token x64Parser::tokenBranches1367[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1368, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1377(x64Operand& operand, int tokenPos) { operand.addressCoding = 128; } -x64Token x64Parser::tokenBranches1376[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1377, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1358(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1367(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1376(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2118[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2119 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2403, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2118(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1357[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1358, x64Parser::tokenBranches1358}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1367, x64Parser::tokenBranches1367}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1376, x64Parser::tokenBranches1376}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1350(x64Operand& operand, int tokenPos) { operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches1349[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1350, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1357}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1221(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1349(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2117[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2118, x64Parser::tokenBranches2118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches1220[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1221, x64Parser::tokenBranches1221}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1349, x64Parser::tokenBranches1349}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches1219[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1220}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3748(x64Operand& operand, int tokenPos) { operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches3747[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3748, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3757(x64Operand& operand, int tokenPos) { operand.addressCoding = 310; } -x64Token x64Parser::tokenBranches3756[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3757, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3766(x64Operand& operand, int tokenPos) { operand.addressCoding = 311; } -x64Token x64Parser::tokenBranches3765[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3766, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3747(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3756(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3765(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2689(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 203; } -x64Token x64Parser::tokenBranches3746[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3747, x64Parser::tokenBranches3747}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3756, x64Parser::tokenBranches3756}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3765, x64Parser::tokenBranches3765}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3739(x64Operand& operand, int tokenPos) { operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches3738[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3739, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3746}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3876(x64Operand& operand, int tokenPos) { operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches3875[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3876, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3885(x64Operand& operand, int tokenPos) { operand.addressCoding = 319; } -x64Token x64Parser::tokenBranches3884[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3885, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3894(x64Operand& operand, int tokenPos) { operand.addressCoding = 320; } -x64Token x64Parser::tokenBranches3893[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3894, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3875(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3884(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3893(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2688[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2689, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2960(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches3874[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3875, x64Parser::tokenBranches3875}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3884, x64Parser::tokenBranches3884}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3893, x64Parser::tokenBranches3893}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3867(x64Operand& operand, int tokenPos) { operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches3866[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3867, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3874}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3738(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3866(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2959[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2960, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2129(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3737[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3738, x64Parser::tokenBranches3738}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3866, x64Parser::tokenBranches3866}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3736[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3737}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4004(x64Operand& operand, int tokenPos) { operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches4003[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4004, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4013(x64Operand& operand, int tokenPos) { operand.addressCoding = 328; } -x64Token x64Parser::tokenBranches4012[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4013, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4022(x64Operand& operand, int tokenPos) { operand.addressCoding = 329; } -x64Token x64Parser::tokenBranches4021[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4022, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4003(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4012(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4021(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2688(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4002[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4003, x64Parser::tokenBranches4003}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4012, x64Parser::tokenBranches4012}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4021, x64Parser::tokenBranches4021}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3995(x64Operand& operand, int tokenPos) { operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches3994[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3995, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4002}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4132(x64Operand& operand, int tokenPos) { operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches4131[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4132, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4141(x64Operand& operand, int tokenPos) { operand.addressCoding = 337; } -x64Token x64Parser::tokenBranches4140[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4141, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4150(x64Operand& operand, int tokenPos) { operand.addressCoding = 338; } -x64Token x64Parser::tokenBranches4149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4131(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4140(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4149(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2959(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4130[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4131, x64Parser::tokenBranches4131}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4140, x64Parser::tokenBranches4140}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4149, x64Parser::tokenBranches4149}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4123(x64Operand& operand, int tokenPos) { operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches4122[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4123, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4130}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3994(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4122(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2128[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2129, x64Parser::tokenBranches2129 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2688, x64Parser::tokenBranches2688 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2959, x64Parser::tokenBranches2959 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2410(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 177; +} +x64Token x64Parser::tokenBranches2116[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2117 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2128 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2410, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc605(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc701(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc825(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2116(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches3993[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3994, x64Parser::tokenBranches3994}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4122, x64Parser::tokenBranches4122}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3992[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3993}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc78(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc525(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc564(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches604[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc605, x64Parser::tokenBranches605 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc701, x64Parser::tokenBranches701 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc825, x64Parser::tokenBranches825 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2116, x64Parser::tokenBranches2116 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc506(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches7[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches33}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches54}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches505}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches510}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1219}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3736}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3992}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc8, x64Parser::tokenBranches8}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc78, x64Parser::tokenBranches78}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc525, x64Parser::tokenBranches525}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc564, x64Parser::tokenBranches564}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches7}, - {x64Token::EOT}}; -void x64Parser::TokenFunc14(x64Operand& operand, int tokenPos) { operand.addressCoding = 2; } -x64Token x64Parser::tokenBranches13[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc14, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc209(x64Operand& operand, int tokenPos) { operand.addressCoding = 21; } -x64Token x64Parser::tokenBranches208[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc209, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc355(x64Operand& operand, int tokenPos) { operand.addressCoding = 36; } -x64Token x64Parser::tokenBranches354[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc355, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc208(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc354(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches505[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc506, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches604 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc613(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 67; } -x64Token x64Parser::tokenBranches207[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc208, x64Parser::tokenBranches208}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc354, x64Parser::tokenBranches354}, - {x64Token::EOT}}; -void x64Parser::TokenFunc43(x64Operand& operand, int tokenPos) { operand.addressCoding = 6; } -x64Token x64Parser::tokenBranches42[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc43, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches207}, - {x64Token::EOT}}; -void x64Parser::TokenFunc144(x64Operand& operand, int tokenPos) { operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches143[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc144, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc290(x64Operand& operand, int tokenPos) { operand.addressCoding = 29; } -x64Token x64Parser::tokenBranches289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc290, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc436(x64Operand& operand, int tokenPos) { operand.addressCoding = 44; } -x64Token x64Parser::tokenBranches435[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc436, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc42(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc143(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc289(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc435(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches612[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc613, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc709(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 71; } -x64Token x64Parser::tokenBranches41[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc42, x64Parser::tokenBranches42}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc143, x64Parser::tokenBranches143}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc289, x64Parser::tokenBranches289}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc435, x64Parser::tokenBranches435}, - {x64Token::EOT}}; -void x64Parser::TokenFunc102(x64Operand& operand, int tokenPos) { operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches40[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches41}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc218(x64Operand& operand, int tokenPos) { operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc364(x64Operand& operand, int tokenPos) { operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches363[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc364, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc217(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc363(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches708[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc709, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc833(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 85; } -x64Token x64Parser::tokenBranches216[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc217, x64Parser::tokenBranches217}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc363, x64Parser::tokenBranches363}, - {x64Token::EOT}}; -void x64Parser::TokenFunc50(x64Operand& operand, int tokenPos) { operand.addressCoding = 5; } -x64Token x64Parser::tokenBranches49[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc50, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches216}, - {x64Token::EOT}}; -void x64Parser::TokenFunc163(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches162[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc163, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc309(x64Operand& operand, int tokenPos) { operand.addressCoding = 31; } -x64Token x64Parser::tokenBranches308[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc309, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc455(x64Operand& operand, int tokenPos) { operand.addressCoding = 46; } -x64Token x64Parser::tokenBranches454[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc455, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc49(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc162(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc308(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc454(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches832[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc833, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2101(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches48[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc49, x64Parser::tokenBranches49}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc162, x64Parser::tokenBranches162}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc308, x64Parser::tokenBranches308}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc454, x64Parser::tokenBranches454}, - {x64Token::EOT}}; -void x64Parser::TokenFunc115(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches47[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches48}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc115, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc264(x64Operand& operand, int tokenPos) { operand.addressCoding = 26; } -x64Token x64Parser::tokenBranches263[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc264, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc410(x64Operand& operand, int tokenPos) { operand.addressCoding = 41; } -x64Token x64Parser::tokenBranches409[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc410, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc263(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc409(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2100[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2101, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2660(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 200; } -x64Token x64Parser::tokenBranches262[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc263, x64Parser::tokenBranches263}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc409, x64Parser::tokenBranches409}, - {x64Token::EOT}}; -void x64Parser::TokenFunc84(x64Operand& operand, int tokenPos) { operand.addressCoding = 11; } -x64Token x64Parser::tokenBranches83[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc84, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches262}, - {x64Token::EOT}}; -void x64Parser::TokenFunc592(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches591[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc592, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc716(x64Operand& operand, int tokenPos) { operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches715[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc716, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc840(x64Operand& operand, int tokenPos) { operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches839[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc840, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2161(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2160[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2161, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2720(x64Operand& operand, int tokenPos) { operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2719[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2720, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2991(x64Operand& operand, int tokenPos) { operand.addressCoding = 226; } -x64Token x64Parser::tokenBranches2990[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2991, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2160(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2719(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2990(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2659[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2660, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2931(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2159[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2160, x64Parser::tokenBranches2160}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2719, x64Parser::tokenBranches2719}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2990, x64Parser::tokenBranches2990}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2435(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2158[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2159}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2435, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2158(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2930[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2931, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2100(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2157[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2158, x64Parser::tokenBranches2158}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2170(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2729(x64Operand& operand, int tokenPos) { operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches2728[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2729, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3000(x64Operand& operand, int tokenPos) { operand.addressCoding = 227; } -x64Token x64Parser::tokenBranches2999[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3000, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2169(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2728(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2999(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2659(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2168[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2169, x64Parser::tokenBranches2169}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2728, x64Parser::tokenBranches2728}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2999, x64Parser::tokenBranches2999}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2442(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2156[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2157}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2168}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2442, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc591(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc715(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc839(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2156(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2930(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches590[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc591, x64Parser::tokenBranches591}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc715, x64Parser::tokenBranches715}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc839, x64Parser::tokenBranches839}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2156, x64Parser::tokenBranches2156}, - {x64Token::EOT}}; -void x64Parser::TokenFunc516(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches515[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc516, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches590}, - {x64Token::EOT}}; -void x64Parser::TokenFunc599(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches598[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc599, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc723(x64Operand& operand, int tokenPos) { operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches722[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc723, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc847(x64Operand& operand, int tokenPos) { operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches846[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc847, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2141(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2140[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2141, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2700(x64Operand& operand, int tokenPos) { operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches2699[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2700, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2971(x64Operand& operand, int tokenPos) { operand.addressCoding = 224; } -x64Token x64Parser::tokenBranches2970[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2971, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2140(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2699(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2970(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2099[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2100, x64Parser::tokenBranches2100 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2659, x64Parser::tokenBranches2659 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2930, x64Parser::tokenBranches2930 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2387(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2139[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2140, x64Parser::tokenBranches2140}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2699, x64Parser::tokenBranches2699}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2970, x64Parser::tokenBranches2970}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2419(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2138[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2139}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2419, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2138(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2098[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2099 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2098(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2137[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2138, x64Parser::tokenBranches2138}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2150(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2709(x64Operand& operand, int tokenPos) { operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches2708[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2709, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2980(x64Operand& operand, int tokenPos) { operand.addressCoding = 225; } -x64Token x64Parser::tokenBranches2979[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2980, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2149(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2708(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2979(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2097[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2098, x64Parser::tokenBranches2098 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2148[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2149, x64Parser::tokenBranches2149}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2708, x64Parser::tokenBranches2708}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2979, x64Parser::tokenBranches2979}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2426(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2136[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2137}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2148}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2426, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2228(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2227[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2228, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2640(x64Operand& operand, int tokenPos) { operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches2639[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2640, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3018(x64Operand& operand, int tokenPos) { operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches3017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2227(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2639(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3017(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 201; } -x64Token x64Parser::tokenBranches2226[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2227, x64Parser::tokenBranches2227}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2639, x64Parser::tokenBranches2639}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3017, x64Parser::tokenBranches3017}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2456(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2225[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2226}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2456, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc598(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc722(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc846(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2136(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2669, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2940(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches597[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2225}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc598, x64Parser::tokenBranches598}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc722, x64Parser::tokenBranches722}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc846, x64Parser::tokenBranches846}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2136, x64Parser::tokenBranches2136}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1009(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches1008[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1009, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1018(x64Operand& operand, int tokenPos) { operand.addressCoding = 97; } -x64Token x64Parser::tokenBranches1017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1027(x64Operand& operand, int tokenPos) { operand.addressCoding = 98; } -x64Token x64Parser::tokenBranches1026[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1027, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1008(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1017(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1026(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2939[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2940, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2109(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1007[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1008, x64Parser::tokenBranches1008}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1017, x64Parser::tokenBranches1017}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1026, x64Parser::tokenBranches1026}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1000(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches999[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1000, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1007}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1137(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1146(x64Operand& operand, int tokenPos) { operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches1145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1155(x64Operand& operand, int tokenPos) { operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches1154[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1155, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1136(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1145(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1154(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2668(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1135[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1136, x64Parser::tokenBranches1136}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1145, x64Parser::tokenBranches1145}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1154, x64Parser::tokenBranches1154}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1128(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1127[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1128, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1135}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1505(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1504[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1505, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1514(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1513[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1514, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1504(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1513(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2939(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1503[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1504, x64Parser::tokenBranches1504}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1513, x64Parser::tokenBranches1513}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1496(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1495[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1496, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1503}, - {x64Token::EOT}}; -void x64Parser::TokenFunc999(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1127(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1495(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2108[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2109, x64Parser::tokenBranches2109 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2668, x64Parser::tokenBranches2668 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2939, x64Parser::tokenBranches2939 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2394(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches998[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc999, x64Parser::tokenBranches999}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1127, x64Parser::tokenBranches1127}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1495, x64Parser::tokenBranches1495}, - {x64Token::EOT}}; -void x64Parser::TokenFunc521(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc521, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches597}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches998}, - {x64Token::EOT}}; -void x64Parser::TokenFunc669(x64Operand& operand, int tokenPos) { operand.addressCoding = 60; } -x64Token x64Parser::tokenBranches668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc669, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc793(x64Operand& operand, int tokenPos) { operand.addressCoding = 79; } -x64Token x64Parser::tokenBranches792[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc793, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc917(x64Operand& operand, int tokenPos) { operand.addressCoding = 93; } -x64Token x64Parser::tokenBranches916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc917, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc668(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc792(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc916(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2096[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2097 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2108 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2394, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2219(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches667[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc668, x64Parser::tokenBranches668}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc792, x64Parser::tokenBranches792}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc916, x64Parser::tokenBranches916}, - {x64Token::EOT}}; -void x64Parser::TokenFunc545(x64Operand& operand, int tokenPos) { operand.addressCoding = 60; } -x64Token x64Parser::tokenBranches544[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc545, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches667}, - {x64Token::EOT}}; -void x64Parser::TokenFunc660(x64Operand& operand, int tokenPos) { operand.addressCoding = 59; } -x64Token x64Parser::tokenBranches659[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc660, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc784(x64Operand& operand, int tokenPos) { operand.addressCoding = 78; } -x64Token x64Parser::tokenBranches783[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc784, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc908(x64Operand& operand, int tokenPos) { operand.addressCoding = 92; } -x64Token x64Parser::tokenBranches907[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2320(x64Operand& operand, int tokenPos) { operand.addressCoding = 189; } -x64Token x64Parser::tokenBranches2319[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2320, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2852(x64Operand& operand, int tokenPos) { operand.addressCoding = 215; } -x64Token x64Parser::tokenBranches2851[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2852, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3150(x64Operand& operand, int tokenPos) { operand.addressCoding = 240; } -x64Token x64Parser::tokenBranches3149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2319(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2851(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3149(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2218[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2219, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2631(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 198; } -x64Token x64Parser::tokenBranches2318[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2319, x64Parser::tokenBranches2319}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2851, x64Parser::tokenBranches2851}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3149, x64Parser::tokenBranches3149}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2560(x64Operand& operand, int tokenPos) { operand.addressCoding = 189; } -x64Token x64Parser::tokenBranches2317[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2318}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2317(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2630[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2631, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3009(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 228; } -x64Token x64Parser::tokenBranches2316[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2317, x64Parser::tokenBranches2317}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2329(x64Operand& operand, int tokenPos) { operand.addressCoding = 190; } -x64Token x64Parser::tokenBranches2328[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2329, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2861(x64Operand& operand, int tokenPos) { operand.addressCoding = 216; } -x64Token x64Parser::tokenBranches2860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3159(x64Operand& operand, int tokenPos) { operand.addressCoding = 241; } -x64Token x64Parser::tokenBranches3158[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3159, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2328(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2860(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3158(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3008[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3009, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2218(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2327[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2328, x64Parser::tokenBranches2328}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2860, x64Parser::tokenBranches2860}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3158, x64Parser::tokenBranches3158}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2567(x64Operand& operand, int tokenPos) { operand.addressCoding = 190; } -x64Token x64Parser::tokenBranches2315[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2316}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2327}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2567, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc659(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc783(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc907(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2315(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2630(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches543[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches544}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc659, x64Parser::tokenBranches659}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc783, x64Parser::tokenBranches783}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc907, x64Parser::tokenBranches907}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2315, x64Parser::tokenBranches2315}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1659(x64Operand& operand, int tokenPos) { operand.addressCoding = 141; } -x64Token x64Parser::tokenBranches1658[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1659, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1668(x64Operand& operand, int tokenPos) { operand.addressCoding = 142; } -x64Token x64Parser::tokenBranches1667[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1668, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1677(x64Operand& operand, int tokenPos) { operand.addressCoding = 143; } -x64Token x64Parser::tokenBranches1676[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1677, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1658(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1667(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1676(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3008(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1657[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1658, x64Parser::tokenBranches1658}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1667, x64Parser::tokenBranches1667}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1676, x64Parser::tokenBranches1676}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1650(x64Operand& operand, int tokenPos) { operand.addressCoding = 141; } -x64Token x64Parser::tokenBranches1649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1650, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1657}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1787(x64Operand& operand, int tokenPos) { operand.addressCoding = 150; } -x64Token x64Parser::tokenBranches1786[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1787, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1796(x64Operand& operand, int tokenPos) { operand.addressCoding = 151; } -x64Token x64Parser::tokenBranches1795[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1796, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1805(x64Operand& operand, int tokenPos) { operand.addressCoding = 152; } -x64Token x64Parser::tokenBranches1804[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1805, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1786(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1795(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1804(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2217[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2218, x64Parser::tokenBranches2218 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2630, x64Parser::tokenBranches2630 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3008, x64Parser::tokenBranches3008 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2449(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 182; +} +x64Token x64Parser::tokenBranches2216[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2217 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2449, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc612(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc708(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc832(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2096(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches1785[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1786, x64Parser::tokenBranches1786}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1795, x64Parser::tokenBranches1795}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1804, x64Parser::tokenBranches1804}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1778(x64Operand& operand, int tokenPos) { operand.addressCoding = 150; } -x64Token x64Parser::tokenBranches1777[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1778, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1785}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1955(x64Operand& operand, int tokenPos) { operand.addressCoding = 161; } -x64Token x64Parser::tokenBranches1954[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1955, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1964(x64Operand& operand, int tokenPos) { operand.addressCoding = 162; } -x64Token x64Parser::tokenBranches1963[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1964, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1984(x64Operand& operand, int tokenPos) { operand.addressCoding = 163; } -x64Token x64Parser::tokenBranches1983[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1984, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1995(x64Operand& operand, int tokenPos) { operand.addressCoding = 164; } -x64Token x64Parser::tokenBranches1994[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1995, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1983(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1994(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches611[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2216 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc612, x64Parser::tokenBranches612 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc708, x64Parser::tokenBranches708 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc832, x64Parser::tokenBranches832 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2096, x64Parser::tokenBranches2096 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc975(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 99; +} +x64Token x64Parser::tokenBranches974[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc975, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc984(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 100; +} +x64Token x64Parser::tokenBranches983[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc984, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc993(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 101; +} +x64Token x64Parser::tokenBranches992[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc993, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc974(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc983(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc992(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1982[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1983, x64Parser::tokenBranches1983}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1994, x64Parser::tokenBranches1994}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1973(x64Operand& operand, int tokenPos) { operand.addressCoding = 163; } -x64Token x64Parser::tokenBranches1972[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1973, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1982}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1954(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1963(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches973[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc974, x64Parser::tokenBranches974 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc983, x64Parser::tokenBranches983 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc992, x64Parser::tokenBranches992 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc966(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches1953[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1972}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1954, x64Parser::tokenBranches1954}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1963, x64Parser::tokenBranches1963}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1946(x64Operand& operand, int tokenPos) { operand.addressCoding = 160; } -x64Token x64Parser::tokenBranches1945[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1946, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1953}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1649(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1777(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1945(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches965[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc966, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches973 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1103(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1648[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1649, x64Parser::tokenBranches1649}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1777, x64Parser::tokenBranches1777}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1945, x64Parser::tokenBranches1945}, - {x64Token::EOT}}; -void x64Parser::TokenFunc531(x64Operand& operand, int tokenPos) { operand.addressCoding = 59; } -x64Token x64Parser::tokenBranches530[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc531, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches543}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1648}, - {x64Token::EOT}}; -void x64Parser::TokenFunc570(x64Operand& operand, int tokenPos) { operand.addressCoding = 65; } -x64Token x64Parser::tokenBranches569[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc570, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1265(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1265, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1274(x64Operand& operand, int tokenPos) { operand.addressCoding = 115; } -x64Token x64Parser::tokenBranches1273[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1274, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1283(x64Operand& operand, int tokenPos) { operand.addressCoding = 116; } -x64Token x64Parser::tokenBranches1282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1264(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1273(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1282(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1102[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1103, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1112(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 109; } -x64Token x64Parser::tokenBranches1263[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1264, x64Parser::tokenBranches1264}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1273, x64Parser::tokenBranches1273}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1282, x64Parser::tokenBranches1282}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1256(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1255[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1256, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1263}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1393(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1392[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1393, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1402(x64Operand& operand, int tokenPos) { operand.addressCoding = 124; } -x64Token x64Parser::tokenBranches1401[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1402, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1411(x64Operand& operand, int tokenPos) { operand.addressCoding = 125; } -x64Token x64Parser::tokenBranches1410[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1411, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1392(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1401(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1410(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1111[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1112, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1121(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 110; } -x64Token x64Parser::tokenBranches1391[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1392, x64Parser::tokenBranches1392}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1401, x64Parser::tokenBranches1401}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1410, x64Parser::tokenBranches1410}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1384(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1383[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1384, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1391}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1255(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1383(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1120[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1121, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1102(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1254[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1255, x64Parser::tokenBranches1255}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1383, x64Parser::tokenBranches1383}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches1253[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1254}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3782(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3781[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3782, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3791(x64Operand& operand, int tokenPos) { operand.addressCoding = 307; } -x64Token x64Parser::tokenBranches3790[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3791, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3800(x64Operand& operand, int tokenPos) { operand.addressCoding = 308; } -x64Token x64Parser::tokenBranches3799[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3800, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3781(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3790(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3799(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1111(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3780[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3781, x64Parser::tokenBranches3781}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3790, x64Parser::tokenBranches3790}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3799, x64Parser::tokenBranches3799}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3773(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3772[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3773, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3780}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3910(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3909[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3910, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3919(x64Operand& operand, int tokenPos) { operand.addressCoding = 316; } -x64Token x64Parser::tokenBranches3918[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3919, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3928(x64Operand& operand, int tokenPos) { operand.addressCoding = 317; } -x64Token x64Parser::tokenBranches3927[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3928, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3909(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3918(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3927(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1120(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3908[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3909, x64Parser::tokenBranches3909}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3918, x64Parser::tokenBranches3918}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3927, x64Parser::tokenBranches3927}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3901(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3901, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3908}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3772(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3900(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1101[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1102, x64Parser::tokenBranches1102 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1111, x64Parser::tokenBranches1111 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1120, x64Parser::tokenBranches1120 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1094(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches3771[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3772, x64Parser::tokenBranches3772}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3900, x64Parser::tokenBranches3900}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3770[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3771}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4038(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches4037[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4038, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4047(x64Operand& operand, int tokenPos) { operand.addressCoding = 325; } -x64Token x64Parser::tokenBranches4046[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4047, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4056(x64Operand& operand, int tokenPos) { operand.addressCoding = 326; } -x64Token x64Parser::tokenBranches4055[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4056, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4037(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4046(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4055(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1093[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1094, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1101 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1480(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches4036[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4037, x64Parser::tokenBranches4037}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4046, x64Parser::tokenBranches4046}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4055, x64Parser::tokenBranches4055}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4029(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches4028[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4029, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4036}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4166(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4165[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4166, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4175(x64Operand& operand, int tokenPos) { operand.addressCoding = 334; } -x64Token x64Parser::tokenBranches4174[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4175, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4184(x64Operand& operand, int tokenPos) { operand.addressCoding = 335; } -x64Token x64Parser::tokenBranches4183[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4184, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4165(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4174(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4183(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1479[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1480, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1489(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 135; } -x64Token x64Parser::tokenBranches4164[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4165, x64Parser::tokenBranches4165}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4174, x64Parser::tokenBranches4174}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4183, x64Parser::tokenBranches4183}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4157(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4156[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4157, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4164}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4028(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4156(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1488[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1489, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1479(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4027[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4028, x64Parser::tokenBranches4028}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4156, x64Parser::tokenBranches4156}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches4026[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4027}, - {x64Token::EOT}}; -void x64Parser::TokenFunc13(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc83(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc530(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc569(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1488(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches12[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches40}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches47}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches515}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches520}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1253}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3770}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4026}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc13, x64Parser::tokenBranches13}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc83, x64Parser::tokenBranches83}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc530, x64Parser::tokenBranches530}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc569, x64Parser::tokenBranches569}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches11[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches12}, - {x64Token::EOT}}; -void x64Parser::TokenFunc19(x64Operand& operand, int tokenPos) { operand.addressCoding = 3; } -x64Token x64Parser::tokenBranches18[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc19, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc236(x64Operand& operand, int tokenPos) { operand.addressCoding = 23; } -x64Token x64Parser::tokenBranches235[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc236, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc382(x64Operand& operand, int tokenPos) { operand.addressCoding = 38; } -x64Token x64Parser::tokenBranches381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc382, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc235(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc381(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1478[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1479, x64Parser::tokenBranches1479 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1488, x64Parser::tokenBranches1488 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1471(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 134; +} +x64Token x64Parser::tokenBranches1470[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1471, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1478 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc965(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1093(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1470(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches234[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc235, x64Parser::tokenBranches235}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc381, x64Parser::tokenBranches381}, - {x64Token::EOT}}; -void x64Parser::TokenFunc64(x64Operand& operand, int tokenPos) { operand.addressCoding = 8; } -x64Token x64Parser::tokenBranches63[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc64, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches234}, - {x64Token::EOT}}; -void x64Parser::TokenFunc151(x64Operand& operand, int tokenPos) { operand.addressCoding = 15; } -x64Token x64Parser::tokenBranches150[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc151, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc297(x64Operand& operand, int tokenPos) { operand.addressCoding = 30; } -x64Token x64Parser::tokenBranches296[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc297, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc443(x64Operand& operand, int tokenPos) { operand.addressCoding = 45; } -x64Token x64Parser::tokenBranches442[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc443, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc63(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc150(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc296(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc442(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches964[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc965, x64Parser::tokenBranches965 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1093, x64Parser::tokenBranches1093 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1470, x64Parser::tokenBranches1470 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc511(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 58; } -x64Token x64Parser::tokenBranches62[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc63, x64Parser::tokenBranches63}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc150, x64Parser::tokenBranches150}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc296, x64Parser::tokenBranches296}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc442, x64Parser::tokenBranches442}, - {x64Token::EOT}}; -void x64Parser::TokenFunc107(x64Operand& operand, int tokenPos) { operand.addressCoding = 15; } -x64Token x64Parser::tokenBranches61[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches62}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc107, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc245(x64Operand& operand, int tokenPos) { operand.addressCoding = 24; } -x64Token x64Parser::tokenBranches244[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc245, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc391(x64Operand& operand, int tokenPos) { operand.addressCoding = 39; } -x64Token x64Parser::tokenBranches390[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc391, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc244(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc390(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches510[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc511, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches611 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches964 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc653(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches243[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc244, x64Parser::tokenBranches244}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc390, x64Parser::tokenBranches390}, - {x64Token::EOT}}; -void x64Parser::TokenFunc71(x64Operand& operand, int tokenPos) { operand.addressCoding = 9; } -x64Token x64Parser::tokenBranches70[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc71, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches243}, - {x64Token::EOT}}; -void x64Parser::TokenFunc177(x64Operand& operand, int tokenPos) { operand.addressCoding = 18; } -x64Token x64Parser::tokenBranches176[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc177, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc323(x64Operand& operand, int tokenPos) { operand.addressCoding = 33; } -x64Token x64Parser::tokenBranches322[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc323, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc469(x64Operand& operand, int tokenPos) { operand.addressCoding = 48; } -x64Token x64Parser::tokenBranches468[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc469, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc70(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc176(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc322(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc468(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches652[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc653, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc777(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches69[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc70, x64Parser::tokenBranches70}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc176, x64Parser::tokenBranches176}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc322, x64Parser::tokenBranches322}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc468, x64Parser::tokenBranches468}, - {x64Token::EOT}}; -void x64Parser::TokenFunc125(x64Operand& operand, int tokenPos) { operand.addressCoding = 18; } -x64Token x64Parser::tokenBranches68[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches69}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc125, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc271(x64Operand& operand, int tokenPos) { operand.addressCoding = 27; } -x64Token x64Parser::tokenBranches270[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc271, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc417(x64Operand& operand, int tokenPos) { operand.addressCoding = 42; } -x64Token x64Parser::tokenBranches416[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc417, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc270(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc416(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches776[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc777, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc901(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches269[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc270, x64Parser::tokenBranches270}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc416, x64Parser::tokenBranches416}, - {x64Token::EOT}}; -void x64Parser::TokenFunc89(x64Operand& operand, int tokenPos) { operand.addressCoding = 12; } -x64Token x64Parser::tokenBranches88[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc89, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches269}, - {x64Token::EOT}}; -void x64Parser::TokenFunc730(x64Operand& operand, int tokenPos) { operand.addressCoding = 72; } -x64Token x64Parser::tokenBranches729[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc854(x64Operand& operand, int tokenPos) { operand.addressCoding = 86; } -x64Token x64Parser::tokenBranches853[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc854, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2201(x64Operand& operand, int tokenPos) { operand.addressCoding = 180; } -x64Token x64Parser::tokenBranches2200[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2201, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2760(x64Operand& operand, int tokenPos) { operand.addressCoding = 206; } -x64Token x64Parser::tokenBranches2759[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2760, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3058(x64Operand& operand, int tokenPos) { operand.addressCoding = 232; } -x64Token x64Parser::tokenBranches3057[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3058, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2200(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2759(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3057(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches900[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc901, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc652(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2199[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2200, x64Parser::tokenBranches2200}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2759, x64Parser::tokenBranches2759}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3057, x64Parser::tokenBranches3057}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2488(x64Operand& operand, int tokenPos) { operand.addressCoding = 180; } -x64Token x64Parser::tokenBranches2198[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2199}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2488, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2198(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc776(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2197[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2198, x64Parser::tokenBranches2198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2210(x64Operand& operand, int tokenPos) { operand.addressCoding = 181; } -x64Token x64Parser::tokenBranches2209[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2210, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2769(x64Operand& operand, int tokenPos) { operand.addressCoding = 207; } -x64Token x64Parser::tokenBranches2768[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2769, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3067(x64Operand& operand, int tokenPos) { operand.addressCoding = 233; } -x64Token x64Parser::tokenBranches3066[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3067, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2209(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2768(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3066(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc900(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2208[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2209, x64Parser::tokenBranches2209}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2768, x64Parser::tokenBranches2768}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3066, x64Parser::tokenBranches3066}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2495(x64Operand& operand, int tokenPos) { operand.addressCoding = 181; } -x64Token x64Parser::tokenBranches2196[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2197}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2208}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2495, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc729(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc853(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2196(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches651[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc652, x64Parser::tokenBranches652 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc776, x64Parser::tokenBranches776 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc900, x64Parser::tokenBranches900 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc538(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches728[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc729, x64Parser::tokenBranches729}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc853, x64Parser::tokenBranches853}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2196, x64Parser::tokenBranches2196}, - {x64Token::EOT}}; -void x64Parser::TokenFunc491(x64Operand& operand, int tokenPos) { operand.addressCoding = 54; } -x64Token x64Parser::tokenBranches490[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc491, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches728}, - {x64Token::EOT}}; -void x64Parser::TokenFunc737(x64Operand& operand, int tokenPos) { operand.addressCoding = 73; } -x64Token x64Parser::tokenBranches736[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc737, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc861(x64Operand& operand, int tokenPos) { operand.addressCoding = 87; } -x64Token x64Parser::tokenBranches860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2181(x64Operand& operand, int tokenPos) { operand.addressCoding = 178; } -x64Token x64Parser::tokenBranches2180[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2181, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2740(x64Operand& operand, int tokenPos) { operand.addressCoding = 204; } -x64Token x64Parser::tokenBranches2739[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2740, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3038(x64Operand& operand, int tokenPos) { operand.addressCoding = 230; } -x64Token x64Parser::tokenBranches3037[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3038, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2180(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2739(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3037(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches537[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc538, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches651 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc644(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches2179[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2180, x64Parser::tokenBranches2180}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2739, x64Parser::tokenBranches2739}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3037, x64Parser::tokenBranches3037}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2472(x64Operand& operand, int tokenPos) { operand.addressCoding = 178; } -x64Token x64Parser::tokenBranches2178[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2179}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2472, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2178(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches643[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc644, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc768(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches2177[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2178, x64Parser::tokenBranches2178}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2190(x64Operand& operand, int tokenPos) { operand.addressCoding = 179; } -x64Token x64Parser::tokenBranches2189[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2190, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2749(x64Operand& operand, int tokenPos) { operand.addressCoding = 205; } -x64Token x64Parser::tokenBranches2748[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2749, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3047(x64Operand& operand, int tokenPos) { operand.addressCoding = 231; } -x64Token x64Parser::tokenBranches3046[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3047, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2189(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2748(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3046(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches767[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc768, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc892(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches2188[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2189, x64Parser::tokenBranches2189}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2748, x64Parser::tokenBranches2748}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3046, x64Parser::tokenBranches3046}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2479(x64Operand& operand, int tokenPos) { operand.addressCoding = 179; } -x64Token x64Parser::tokenBranches2176[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2177}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2188}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2479, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2237(x64Operand& operand, int tokenPos) { operand.addressCoding = 183; } -x64Token x64Parser::tokenBranches2236[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2237, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2649(x64Operand& operand, int tokenPos) { operand.addressCoding = 199; } -x64Token x64Parser::tokenBranches2648[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2649, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3027(x64Operand& operand, int tokenPos) { operand.addressCoding = 229; } -x64Token x64Parser::tokenBranches3026[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3027, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2236(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2648(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3026(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches891[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc892, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2235[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2236, x64Parser::tokenBranches2236}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2648, x64Parser::tokenBranches2648}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3026, x64Parser::tokenBranches3026}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2463(x64Operand& operand, int tokenPos) { operand.addressCoding = 183; } -x64Token x64Parser::tokenBranches2234[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2235}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2463, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc736(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc860(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2176(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2832(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 214; } -x64Token x64Parser::tokenBranches735[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2234}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc736, x64Parser::tokenBranches736}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc860, x64Parser::tokenBranches860}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2176, x64Parser::tokenBranches2176}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1043(x64Operand& operand, int tokenPos) { operand.addressCoding = 102; } -x64Token x64Parser::tokenBranches1042[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1043, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1052(x64Operand& operand, int tokenPos) { operand.addressCoding = 103; } -x64Token x64Parser::tokenBranches1051[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1052, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1061(x64Operand& operand, int tokenPos) { operand.addressCoding = 104; } -x64Token x64Parser::tokenBranches1060[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1061, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1042(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1051(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1060(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2831[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2832, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches1041[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1042, x64Parser::tokenBranches1042}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1051, x64Parser::tokenBranches1051}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1060, x64Parser::tokenBranches1060}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1034(x64Operand& operand, int tokenPos) { operand.addressCoding = 102; } -x64Token x64Parser::tokenBranches1033[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1034, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1041}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1171(x64Operand& operand, int tokenPos) { operand.addressCoding = 111; } -x64Token x64Parser::tokenBranches1170[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1171, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1180(x64Operand& operand, int tokenPos) { operand.addressCoding = 112; } -x64Token x64Parser::tokenBranches1179[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1180, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1189(x64Operand& operand, int tokenPos) { operand.addressCoding = 113; } -x64Token x64Parser::tokenBranches1188[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1189, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1170(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1179(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1188(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2299(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1169[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1170, x64Parser::tokenBranches1170}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1179, x64Parser::tokenBranches1179}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1188, x64Parser::tokenBranches1188}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1162(x64Operand& operand, int tokenPos) { operand.addressCoding = 111; } -x64Token x64Parser::tokenBranches1161[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1162, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1169}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1530(x64Operand& operand, int tokenPos) { operand.addressCoding = 136; } -x64Token x64Parser::tokenBranches1529[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1530, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1539(x64Operand& operand, int tokenPos) { operand.addressCoding = 137; } -x64Token x64Parser::tokenBranches1538[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1539, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1529(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1538(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2831(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1528[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1529, x64Parser::tokenBranches1529}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1538, x64Parser::tokenBranches1538}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1521(x64Operand& operand, int tokenPos) { operand.addressCoding = 136; } -x64Token x64Parser::tokenBranches1520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1521, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1528}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1033(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1161(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1520(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3129(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1032[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1033, x64Parser::tokenBranches1033}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1161, x64Parser::tokenBranches1161}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1520, x64Parser::tokenBranches1520}, - {x64Token::EOT}}; -void x64Parser::TokenFunc496(x64Operand& operand, int tokenPos) { operand.addressCoding = 55; } -x64Token x64Parser::tokenBranches495[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc496, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches735}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1032}, - {x64Token::EOT}}; -void x64Parser::TokenFunc637(x64Operand& operand, int tokenPos) { operand.addressCoding = 56; } -x64Token x64Parser::tokenBranches636[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc637, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc761(x64Operand& operand, int tokenPos) { operand.addressCoding = 77; } -x64Token x64Parser::tokenBranches760[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc761, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc885(x64Operand& operand, int tokenPos) { operand.addressCoding = 91; } -x64Token x64Parser::tokenBranches884[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc885, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2280(x64Operand& operand, int tokenPos) { operand.addressCoding = 187; } -x64Token x64Parser::tokenBranches2279[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2280, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2812(x64Operand& operand, int tokenPos) { operand.addressCoding = 212; } -x64Token x64Parser::tokenBranches2811[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2812, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3110(x64Operand& operand, int tokenPos) { operand.addressCoding = 238; } -x64Token x64Parser::tokenBranches3109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2279(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2811(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3109(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2298[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2299, x64Parser::tokenBranches2299 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2831, x64Parser::tokenBranches2831 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3129, x64Parser::tokenBranches3129 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2544(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2278[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2279, x64Parser::tokenBranches2279}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2811, x64Parser::tokenBranches2811}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3109, x64Parser::tokenBranches3109}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2528(x64Operand& operand, int tokenPos) { operand.addressCoding = 187; } -x64Token x64Parser::tokenBranches2277[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2278}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2528, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2277(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2297[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2298 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2544, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2297(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2276[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2277, x64Parser::tokenBranches2277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2289(x64Operand& operand, int tokenPos) { operand.addressCoding = 188; } -x64Token x64Parser::tokenBranches2288[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2289, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2821(x64Operand& operand, int tokenPos) { operand.addressCoding = 213; } -x64Token x64Parser::tokenBranches2820[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2821, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3119(x64Operand& operand, int tokenPos) { operand.addressCoding = 239; } -x64Token x64Parser::tokenBranches3118[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3119, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2288(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2820(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3118(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2296[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2297, x64Parser::tokenBranches2297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2309(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2287[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2288, x64Parser::tokenBranches2288}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2820, x64Parser::tokenBranches2820}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3118, x64Parser::tokenBranches3118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2535(x64Operand& operand, int tokenPos) { operand.addressCoding = 188; } -x64Token x64Parser::tokenBranches2275[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2276}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2287}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2535, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc636(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc760(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc884(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2275(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2308[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2309, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2841(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches635[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc636, x64Parser::tokenBranches636}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc760, x64Parser::tokenBranches760}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc884, x64Parser::tokenBranches884}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2275, x64Parser::tokenBranches2275}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1299(x64Operand& operand, int tokenPos) { operand.addressCoding = 120; } -x64Token x64Parser::tokenBranches1298[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1299, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1308(x64Operand& operand, int tokenPos) { operand.addressCoding = 121; } -x64Token x64Parser::tokenBranches1307[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1308, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1317(x64Operand& operand, int tokenPos) { operand.addressCoding = 122; } -x64Token x64Parser::tokenBranches1316[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1317, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1298(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1307(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1316(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2840[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2841, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3139(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches1297[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1298, x64Parser::tokenBranches1298}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1307, x64Parser::tokenBranches1307}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1316, x64Parser::tokenBranches1316}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1290(x64Operand& operand, int tokenPos) { operand.addressCoding = 120; } -x64Token x64Parser::tokenBranches1289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1290, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1427(x64Operand& operand, int tokenPos) { operand.addressCoding = 129; } -x64Token x64Parser::tokenBranches1426[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1427, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1436(x64Operand& operand, int tokenPos) { operand.addressCoding = 130; } -x64Token x64Parser::tokenBranches1435[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1436, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1445(x64Operand& operand, int tokenPos) { operand.addressCoding = 131; } -x64Token x64Parser::tokenBranches1444[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1445, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1426(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1435(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1444(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3138[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3139, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2308(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1425[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1426, x64Parser::tokenBranches1426}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1435, x64Parser::tokenBranches1435}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1444, x64Parser::tokenBranches1444}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1418(x64Operand& operand, int tokenPos) { operand.addressCoding = 129; } -x64Token x64Parser::tokenBranches1417[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1418, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1425}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1574(x64Operand& operand, int tokenPos) { operand.addressCoding = 139; } -x64Token x64Parser::tokenBranches1573[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1574, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1583(x64Operand& operand, int tokenPos) { operand.addressCoding = 140; } -x64Token x64Parser::tokenBranches1582[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1583, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1573(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1582(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2840(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1572[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1573, x64Parser::tokenBranches1573}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1582, x64Parser::tokenBranches1582}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1565(x64Operand& operand, int tokenPos) { operand.addressCoding = 139; } -x64Token x64Parser::tokenBranches1564[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1565, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1572}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1289(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1417(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1564(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3138(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1288[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1289, x64Parser::tokenBranches1289}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1417, x64Parser::tokenBranches1417}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1564, x64Parser::tokenBranches1564}, - {x64Token::EOT}}; -void x64Parser::TokenFunc501(x64Operand& operand, int tokenPos) { operand.addressCoding = 56; } -x64Token x64Parser::tokenBranches500[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc501, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches635}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1288}, - {x64Token::EOT}}; -void x64Parser::TokenFunc685(x64Operand& operand, int tokenPos) { operand.addressCoding = 62; } -x64Token x64Parser::tokenBranches684[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc685, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc809(x64Operand& operand, int tokenPos) { operand.addressCoding = 81; } -x64Token x64Parser::tokenBranches808[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc809, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc926(x64Operand& operand, int tokenPos) { operand.addressCoding = 94; } -x64Token x64Parser::tokenBranches925[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc926, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc684(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc808(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc925(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2307[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2308, x64Parser::tokenBranches2308 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2840, x64Parser::tokenBranches2840 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3138, x64Parser::tokenBranches3138 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2551(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2295[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2296 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2307 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc643(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc767(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc891(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2295(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches683[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc684, x64Parser::tokenBranches684}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc808, x64Parser::tokenBranches808}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc925, x64Parser::tokenBranches925}, - {x64Token::EOT}}; -void x64Parser::TokenFunc557(x64Operand& operand, int tokenPos) { operand.addressCoding = 62; } -x64Token x64Parser::tokenBranches556[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc557, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches683}, - {x64Token::EOT}}; -void x64Parser::TokenFunc676(x64Operand& operand, int tokenPos) { operand.addressCoding = 61; } -x64Token x64Parser::tokenBranches675[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc676, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc800(x64Operand& operand, int tokenPos) { operand.addressCoding = 80; } -x64Token x64Parser::tokenBranches799[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc800, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc933(x64Operand& operand, int tokenPos) { operand.addressCoding = 95; } -x64Token x64Parser::tokenBranches932[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc933, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2340(x64Operand& operand, int tokenPos) { operand.addressCoding = 191; } -x64Token x64Parser::tokenBranches2339[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2340, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2872(x64Operand& operand, int tokenPos) { operand.addressCoding = 217; } -x64Token x64Parser::tokenBranches2871[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2872, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3170(x64Operand& operand, int tokenPos) { operand.addressCoding = 242; } -x64Token x64Parser::tokenBranches3169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2339(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2871(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3169(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches536[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches537 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc643, x64Parser::tokenBranches643 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc767, x64Parser::tokenBranches767 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc891, x64Parser::tokenBranches891 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2295, x64Parser::tokenBranches2295 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1625(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1624[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1625, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1634(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches1633[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1634, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1643(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches1642[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1643, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1624(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1633(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1642(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2338[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2339, x64Parser::tokenBranches2339}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2871, x64Parser::tokenBranches2871}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3169, x64Parser::tokenBranches3169}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2576(x64Operand& operand, int tokenPos) { operand.addressCoding = 191; } -x64Token x64Parser::tokenBranches2337[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2338}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2576, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2337(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1623[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1624, x64Parser::tokenBranches1624 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1633, x64Parser::tokenBranches1633 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1642, x64Parser::tokenBranches1642 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1616(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches2336[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2337, x64Parser::tokenBranches2337}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2349(x64Operand& operand, int tokenPos) { operand.addressCoding = 192; } -x64Token x64Parser::tokenBranches2348[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2349, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2881(x64Operand& operand, int tokenPos) { operand.addressCoding = 218; } -x64Token x64Parser::tokenBranches2880[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2881, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3179(x64Operand& operand, int tokenPos) { operand.addressCoding = 243; } -x64Token x64Parser::tokenBranches3178[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3179, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2348(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2880(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3178(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1615[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1616, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1623 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1753(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches2347[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2348, x64Parser::tokenBranches2348}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2880, x64Parser::tokenBranches2880}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3178, x64Parser::tokenBranches3178}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2583(x64Operand& operand, int tokenPos) { operand.addressCoding = 192; } -x64Token x64Parser::tokenBranches2335[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2336}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2347}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2583, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc675(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc799(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc932(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2335(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1752[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1753, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1762(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches555[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches556}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc675, x64Parser::tokenBranches675}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc799, x64Parser::tokenBranches799}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc932, x64Parser::tokenBranches932}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2335, x64Parser::tokenBranches2335}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1693(x64Operand& operand, int tokenPos) { operand.addressCoding = 144; } -x64Token x64Parser::tokenBranches1692[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1693, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1702(x64Operand& operand, int tokenPos) { operand.addressCoding = 145; } -x64Token x64Parser::tokenBranches1701[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1702, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1711(x64Operand& operand, int tokenPos) { operand.addressCoding = 146; } -x64Token x64Parser::tokenBranches1710[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1711, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1692(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1701(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1710(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1761[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1762, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1771(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1691[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1692, x64Parser::tokenBranches1692}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1701, x64Parser::tokenBranches1701}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1710, x64Parser::tokenBranches1710}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1684(x64Operand& operand, int tokenPos) { operand.addressCoding = 144; } -x64Token x64Parser::tokenBranches1683[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1684, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1691}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1821(x64Operand& operand, int tokenPos) { operand.addressCoding = 153; } -x64Token x64Parser::tokenBranches1820[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1821, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1830(x64Operand& operand, int tokenPos) { operand.addressCoding = 154; } -x64Token x64Parser::tokenBranches1829[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1830, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1839(x64Operand& operand, int tokenPos) { operand.addressCoding = 155; } -x64Token x64Parser::tokenBranches1838[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1839, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1820(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1829(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1838(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1770[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1771, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1752(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1819[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1820, x64Parser::tokenBranches1820}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1829, x64Parser::tokenBranches1829}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1838, x64Parser::tokenBranches1838}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1812(x64Operand& operand, int tokenPos) { operand.addressCoding = 153; } -x64Token x64Parser::tokenBranches1811[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1812, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1819}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2011(x64Operand& operand, int tokenPos) { operand.addressCoding = 165; } -x64Token x64Parser::tokenBranches2010[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2011, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2020(x64Operand& operand, int tokenPos) { operand.addressCoding = 166; } -x64Token x64Parser::tokenBranches2019[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2020, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2040(x64Operand& operand, int tokenPos) { operand.addressCoding = 167; } -x64Token x64Parser::tokenBranches2039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2051(x64Operand& operand, int tokenPos) { operand.addressCoding = 168; } -x64Token x64Parser::tokenBranches2050[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2051, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2039(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2050(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1761(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2038[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2039, x64Parser::tokenBranches2039}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2050, x64Parser::tokenBranches2050}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2029(x64Operand& operand, int tokenPos) { operand.addressCoding = 167; } -x64Token x64Parser::tokenBranches2028[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2029, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2038}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2010(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2019(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1770(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2009[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2028}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2010, x64Parser::tokenBranches2010}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2019, x64Parser::tokenBranches2019}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2002(x64Operand& operand, int tokenPos) { operand.addressCoding = 165; } -x64Token x64Parser::tokenBranches2001[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2002, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2009}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1683(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1811(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2001(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1751[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1752, x64Parser::tokenBranches1752 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1761, x64Parser::tokenBranches1761 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1770, x64Parser::tokenBranches1770 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1744(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1682[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1683, x64Parser::tokenBranches1683}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1811, x64Parser::tokenBranches1811}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2001, x64Parser::tokenBranches2001}, - {x64Token::EOT}}; -void x64Parser::TokenFunc550(x64Operand& operand, int tokenPos) { operand.addressCoding = 61; } -x64Token x64Parser::tokenBranches549[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc550, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches555}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1682}, - {x64Token::EOT}}; -void x64Parser::TokenFunc575(x64Operand& operand, int tokenPos) { operand.addressCoding = 66; } -x64Token x64Parser::tokenBranches574[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc575, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3277(x64Operand& operand, int tokenPos) { operand.addressCoding = 248; } -x64Token x64Parser::tokenBranches3276[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3277, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3368(x64Operand& operand, int tokenPos) { operand.addressCoding = 264; } -x64Token x64Parser::tokenBranches3367[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3368, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3460(x64Operand& operand, int tokenPos) { operand.addressCoding = 278; } -x64Token x64Parser::tokenBranches3459[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3460, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4569(x64Operand& operand, int tokenPos) { operand.addressCoding = 379; } -x64Token x64Parser::tokenBranches4568[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4569, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4945(x64Operand& operand, int tokenPos) { operand.addressCoding = 403; } -x64Token x64Parser::tokenBranches4944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5157(x64Operand& operand, int tokenPos) { operand.addressCoding = 427; } -x64Token x64Parser::tokenBranches5156[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5157, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4568(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4944(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5156(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1743[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1744, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1751 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1899(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches4567[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4568, x64Parser::tokenBranches4568}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4944, x64Parser::tokenBranches4944}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5156, x64Parser::tokenBranches5156}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4755(x64Operand& operand, int tokenPos) { operand.addressCoding = 379; } -x64Token x64Parser::tokenBranches4566[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4567}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4755, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4566(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1898[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1899, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1908(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches4565[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4566, x64Parser::tokenBranches4566}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4578(x64Operand& operand, int tokenPos) { operand.addressCoding = 380; } -x64Token x64Parser::tokenBranches4577[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4578, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4954(x64Operand& operand, int tokenPos) { operand.addressCoding = 404; } -x64Token x64Parser::tokenBranches4953[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4954, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5166(x64Operand& operand, int tokenPos) { operand.addressCoding = 428; } -x64Token x64Parser::tokenBranches5165[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5166, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4577(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4953(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5165(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1907[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1908, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1928(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches4576[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4577, x64Parser::tokenBranches4577}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4953, x64Parser::tokenBranches4953}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5165, x64Parser::tokenBranches5165}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4762(x64Operand& operand, int tokenPos) { operand.addressCoding = 380; } -x64Token x64Parser::tokenBranches4564[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4565}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4576}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4762, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3276(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3367(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3459(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4564(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1927[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1928, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1939(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches3275[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3276, x64Parser::tokenBranches3276}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3367, x64Parser::tokenBranches3367}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3459, x64Parser::tokenBranches3459}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4564, x64Parser::tokenBranches4564}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3196(x64Operand& operand, int tokenPos) { operand.addressCoding = 248; } -x64Token x64Parser::tokenBranches3195[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3196, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3275}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3337(x64Operand& operand, int tokenPos) { operand.addressCoding = 256; } -x64Token x64Parser::tokenBranches3336[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3337, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3429(x64Operand& operand, int tokenPos) { operand.addressCoding = 273; } -x64Token x64Parser::tokenBranches3428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3521(x64Operand& operand, int tokenPos) { operand.addressCoding = 287; } -x64Token x64Parser::tokenBranches3520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3521, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3336(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3428(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3520(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1938[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1939, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1927(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3335[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3336, x64Parser::tokenBranches3336}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3428, x64Parser::tokenBranches3428}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3520, x64Parser::tokenBranches3520}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3236(x64Operand& operand, int tokenPos) { operand.addressCoding = 256; } -x64Token x64Parser::tokenBranches3235[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3236, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3335}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3375(x64Operand& operand, int tokenPos) { operand.addressCoding = 265; } -x64Token x64Parser::tokenBranches3374[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3375, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3467(x64Operand& operand, int tokenPos) { operand.addressCoding = 279; } -x64Token x64Parser::tokenBranches3466[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3467, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4589(x64Operand& operand, int tokenPos) { operand.addressCoding = 381; } -x64Token x64Parser::tokenBranches4588[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4589, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4965(x64Operand& operand, int tokenPos) { operand.addressCoding = 405; } -x64Token x64Parser::tokenBranches4964[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4965, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5177(x64Operand& operand, int tokenPos) { operand.addressCoding = 429; } -x64Token x64Parser::tokenBranches5176[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5177, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4588(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4964(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5176(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1938(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4587[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4588, x64Parser::tokenBranches4588}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4964, x64Parser::tokenBranches4964}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5176, x64Parser::tokenBranches5176}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4771(x64Operand& operand, int tokenPos) { operand.addressCoding = 381; } -x64Token x64Parser::tokenBranches4586[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4587}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4771, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4586(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1926[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1927, x64Parser::tokenBranches1927 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1938, x64Parser::tokenBranches1938 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1917(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1916[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1917, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1926 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1898(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1907(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4585[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4586, x64Parser::tokenBranches4586}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4598(x64Operand& operand, int tokenPos) { operand.addressCoding = 382; } -x64Token x64Parser::tokenBranches4597[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4598, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4974(x64Operand& operand, int tokenPos) { operand.addressCoding = 406; } -x64Token x64Parser::tokenBranches4973[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4974, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5186(x64Operand& operand, int tokenPos) { operand.addressCoding = 430; } -x64Token x64Parser::tokenBranches5185[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5186, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4597(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4973(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5185(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1897[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1916 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1898, x64Parser::tokenBranches1898 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1907, x64Parser::tokenBranches1907 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1890(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1889[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1890, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1897 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1615(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1743(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1889(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4596[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4597, x64Parser::tokenBranches4597}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4973, x64Parser::tokenBranches4973}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5185, x64Parser::tokenBranches5185}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4778(x64Operand& operand, int tokenPos) { operand.addressCoding = 382; } -x64Token x64Parser::tokenBranches4584[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4585}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4596}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3374(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3466(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4584(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1614[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1615, x64Parser::tokenBranches1615 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1743, x64Parser::tokenBranches1743 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1889, x64Parser::tokenBranches1889 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc526(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches3234[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3235}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3374, x64Parser::tokenBranches3374}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3466, x64Parser::tokenBranches3466}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4584, x64Parser::tokenBranches4584}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3283(x64Operand& operand, int tokenPos) { operand.addressCoding = 249; } -x64Token x64Parser::tokenBranches3282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3572(x64Operand& operand, int tokenPos) { operand.addressCoding = 289; } -x64Token x64Parser::tokenBranches3571[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3581(x64Operand& operand, int tokenPos) { operand.addressCoding = 290; } -x64Token x64Parser::tokenBranches3580[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3581, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3590(x64Operand& operand, int tokenPos) { operand.addressCoding = 291; } -x64Token x64Parser::tokenBranches3589[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3590, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3571(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3580(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3589(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches525[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc526, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches536 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1614 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc565(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 64; } -x64Token x64Parser::tokenBranches3570[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3571, x64Parser::tokenBranches3571}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3580, x64Parser::tokenBranches3580}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3589, x64Parser::tokenBranches3589}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3563(x64Operand& operand, int tokenPos) { operand.addressCoding = 289; } -x64Token x64Parser::tokenBranches3562[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3563, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3570}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3632(x64Operand& operand, int tokenPos) { operand.addressCoding = 295; } -x64Token x64Parser::tokenBranches3631[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3632, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3641(x64Operand& operand, int tokenPos) { operand.addressCoding = 296; } -x64Token x64Parser::tokenBranches3640[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3641, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3650(x64Operand& operand, int tokenPos) { operand.addressCoding = 297; } -x64Token x64Parser::tokenBranches3649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3650, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3631(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3640(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3649(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches564[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc565, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1231(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches3630[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3631, x64Parser::tokenBranches3631}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3640, x64Parser::tokenBranches3640}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3649, x64Parser::tokenBranches3649}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3623(x64Operand& operand, int tokenPos) { operand.addressCoding = 295; } -x64Token x64Parser::tokenBranches3622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3623, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3630}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3678(x64Operand& operand, int tokenPos) { operand.addressCoding = 301; } -x64Token x64Parser::tokenBranches3677[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3678, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3677(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1230[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1231, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1240(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 118; } -x64Token x64Parser::tokenBranches3676[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3677, x64Parser::tokenBranches3677}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3669(x64Operand& operand, int tokenPos) { operand.addressCoding = 300; } -x64Token x64Parser::tokenBranches3668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3669, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3676}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3706(x64Operand& operand, int tokenPos) { operand.addressCoding = 305; } -x64Token x64Parser::tokenBranches3705[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3706, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3705(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1239[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1240, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1249(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 119; } -x64Token x64Parser::tokenBranches3704[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3705, x64Parser::tokenBranches3705}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3697(x64Operand& operand, int tokenPos) { operand.addressCoding = 304; } -x64Token x64Parser::tokenBranches3696[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3697, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3704}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3562(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3622(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3668(x64Operand& operand, int tokenPos) -{ - operand.values[13] = new Coding[2]; - CleanupValues.push_back(operand.values[13]); - operand.values[13]->type = Coding::number; - operand.values[13]->val = operands.size(); - operand.values[13]->bits = 0; - operand.values[13]->field = 0; - operand.values[13]->unary = 0; - operand.values[13]->binary = 0; - operand.values[13][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3696(x64Operand& operand, int tokenPos) -{ - operand.values[14] = new Coding[2]; - CleanupValues.push_back(operand.values[14]); - operand.values[14]->type = Coding::number; - operand.values[14]->val = operands.size(); - operand.values[14]->bits = 0; - operand.values[14]->field = 0; - operand.values[14]->unary = 0; - operand.values[14]->binary = 0; - operand.values[14][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1248[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1249, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1230(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3561[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3562, x64Parser::tokenBranches3562}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3622, x64Parser::tokenBranches3622}, - {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3668, x64Parser::tokenBranches3668}, - {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3696, x64Parser::tokenBranches3696}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3201(x64Operand& operand, int tokenPos) { operand.addressCoding = 249; } -void x64Parser::TokenFunc3282(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1239(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3200[] = { - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3201, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3234}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3282, x64Parser::tokenBranches3282}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3561}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3290(x64Operand& operand, int tokenPos) { operand.addressCoding = 250; } -x64Token x64Parser::tokenBranches3289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3290, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3382(x64Operand& operand, int tokenPos) { operand.addressCoding = 266; } -x64Token x64Parser::tokenBranches3381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3382, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3474(x64Operand& operand, int tokenPos) { operand.addressCoding = 280; } -x64Token x64Parser::tokenBranches3473[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3474, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4481(x64Operand& operand, int tokenPos) { operand.addressCoding = 369; } -x64Token x64Parser::tokenBranches4480[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4481, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4857(x64Operand& operand, int tokenPos) { operand.addressCoding = 393; } -x64Token x64Parser::tokenBranches4856[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4857, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5069(x64Operand& operand, int tokenPos) { operand.addressCoding = 417; } -x64Token x64Parser::tokenBranches5068[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5069, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4480(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4856(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5068(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1248(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4479[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4480, x64Parser::tokenBranches4480}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4856, x64Parser::tokenBranches4856}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5068, x64Parser::tokenBranches5068}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4687(x64Operand& operand, int tokenPos) { operand.addressCoding = 369; } -x64Token x64Parser::tokenBranches4478[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4479}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4687, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4549(x64Operand& operand, int tokenPos) { operand.addressCoding = 377; } -x64Token x64Parser::tokenBranches4548[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4549, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4925(x64Operand& operand, int tokenPos) { operand.addressCoding = 401; } -x64Token x64Parser::tokenBranches4924[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4925, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5137(x64Operand& operand, int tokenPos) { operand.addressCoding = 425; } -x64Token x64Parser::tokenBranches5136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4548(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4924(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5136(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1229[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1230, x64Parser::tokenBranches1230 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1239, x64Parser::tokenBranches1239 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1248, x64Parser::tokenBranches1248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1222(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches4547[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4548, x64Parser::tokenBranches4548}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4924, x64Parser::tokenBranches4924}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5136, x64Parser::tokenBranches5136}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4739(x64Operand& operand, int tokenPos) { operand.addressCoding = 377; } -x64Token x64Parser::tokenBranches4546[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4547}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4739, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4546(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1221[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1222, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1229 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1359(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches4545[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4546, x64Parser::tokenBranches4546}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4558(x64Operand& operand, int tokenPos) { operand.addressCoding = 378; } -x64Token x64Parser::tokenBranches4557[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4558, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4934(x64Operand& operand, int tokenPos) { operand.addressCoding = 402; } -x64Token x64Parser::tokenBranches4933[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4934, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5146(x64Operand& operand, int tokenPos) { operand.addressCoding = 426; } -x64Token x64Parser::tokenBranches5145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4557(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4933(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5145(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1358[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1359, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1368(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 127; } -x64Token x64Parser::tokenBranches4556[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4557, x64Parser::tokenBranches4557}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4933, x64Parser::tokenBranches4933}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5145, x64Parser::tokenBranches5145}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4746(x64Operand& operand, int tokenPos) { operand.addressCoding = 378; } -x64Token x64Parser::tokenBranches4544[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4545}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4556}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4746, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3289(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3381(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3473(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4544(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1367[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1368, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1377(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 128; } -x64Token x64Parser::tokenBranches3288[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4478}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3289, x64Parser::tokenBranches3289}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3381, x64Parser::tokenBranches3381}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3473, x64Parser::tokenBranches3473}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4544, x64Parser::tokenBranches4544}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3816(x64Operand& operand, int tokenPos) { operand.addressCoding = 312; } -x64Token x64Parser::tokenBranches3815[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3816, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3825(x64Operand& operand, int tokenPos) { operand.addressCoding = 313; } -x64Token x64Parser::tokenBranches3824[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3825, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3834(x64Operand& operand, int tokenPos) { operand.addressCoding = 314; } -x64Token x64Parser::tokenBranches3833[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3834, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3815(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3824(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3833(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1376[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1377, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1358(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3814[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3815, x64Parser::tokenBranches3815}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3824, x64Parser::tokenBranches3824}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3833, x64Parser::tokenBranches3833}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3807(x64Operand& operand, int tokenPos) { operand.addressCoding = 312; } -x64Token x64Parser::tokenBranches3806[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3807, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3814}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3944(x64Operand& operand, int tokenPos) { operand.addressCoding = 321; } -x64Token x64Parser::tokenBranches3943[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3944, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3953(x64Operand& operand, int tokenPos) { operand.addressCoding = 322; } -x64Token x64Parser::tokenBranches3952[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3953, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3962(x64Operand& operand, int tokenPos) { operand.addressCoding = 323; } -x64Token x64Parser::tokenBranches3961[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3962, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3943(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3952(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3961(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1367(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3942[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3943, x64Parser::tokenBranches3943}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3952, x64Parser::tokenBranches3952}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3961, x64Parser::tokenBranches3961}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3935(x64Operand& operand, int tokenPos) { operand.addressCoding = 321; } -x64Token x64Parser::tokenBranches3934[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3935, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3942}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4246(x64Operand& operand, int tokenPos) { operand.addressCoding = 345; } -x64Token x64Parser::tokenBranches4245[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4245(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1376(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4244[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4245, x64Parser::tokenBranches4245}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4237(x64Operand& operand, int tokenPos) { operand.addressCoding = 344; } -x64Token x64Parser::tokenBranches4236[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4237, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4244}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3806(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3934(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4236(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1357[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1358, x64Parser::tokenBranches1358 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1367, x64Parser::tokenBranches1367 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1376, x64Parser::tokenBranches1376 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1350(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 126; +} +x64Token x64Parser::tokenBranches1349[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1350, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1357 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1221(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1349(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3805[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3806, x64Parser::tokenBranches3806}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3934, x64Parser::tokenBranches3934}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4236, x64Parser::tokenBranches4236}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3206(x64Operand& operand, int tokenPos) { operand.addressCoding = 250; } -x64Token x64Parser::tokenBranches3205[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3206, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3288}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3805}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3321(x64Operand& operand, int tokenPos) { operand.addressCoding = 251; } -x64Token x64Parser::tokenBranches3320[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3321, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3413(x64Operand& operand, int tokenPos) { operand.addressCoding = 271; } -x64Token x64Parser::tokenBranches3412[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3413, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3505(x64Operand& operand, int tokenPos) { operand.addressCoding = 285; } -x64Token x64Parser::tokenBranches3504[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3505, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4490(x64Operand& operand, int tokenPos) { operand.addressCoding = 370; } -x64Token x64Parser::tokenBranches4489[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4490, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4866(x64Operand& operand, int tokenPos) { operand.addressCoding = 394; } -x64Token x64Parser::tokenBranches4865[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4866, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5078(x64Operand& operand, int tokenPos) { operand.addressCoding = 418; } -x64Token x64Parser::tokenBranches5077[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5078, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4489(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4865(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5077(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1220[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1221, x64Parser::tokenBranches1221 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1349, x64Parser::tokenBranches1349 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches1219[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1220 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3748(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches4488[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4489, x64Parser::tokenBranches4489}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4865, x64Parser::tokenBranches4865}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5077, x64Parser::tokenBranches5077}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4694(x64Operand& operand, int tokenPos) { operand.addressCoding = 370; } -x64Token x64Parser::tokenBranches4487[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4488}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4694, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4641(x64Operand& operand, int tokenPos) { operand.addressCoding = 387; } -x64Token x64Parser::tokenBranches4640[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4641, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5017(x64Operand& operand, int tokenPos) { operand.addressCoding = 411; } -x64Token x64Parser::tokenBranches5016[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5017, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5229(x64Operand& operand, int tokenPos) { operand.addressCoding = 435; } -x64Token x64Parser::tokenBranches5228[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5229, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4640(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5016(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5228(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3747[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3748, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3757(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 310; } -x64Token x64Parser::tokenBranches4639[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4640, x64Parser::tokenBranches4640}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5016, x64Parser::tokenBranches5016}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5228, x64Parser::tokenBranches5228}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4811(x64Operand& operand, int tokenPos) { operand.addressCoding = 387; } -x64Token x64Parser::tokenBranches4638[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4639}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4811, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4638(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3756[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3757, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3766(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 311; } -x64Token x64Parser::tokenBranches4637[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4638, x64Parser::tokenBranches4638}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4650(x64Operand& operand, int tokenPos) { operand.addressCoding = 388; } -x64Token x64Parser::tokenBranches4649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4650, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5026(x64Operand& operand, int tokenPos) { operand.addressCoding = 412; } -x64Token x64Parser::tokenBranches5025[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5026, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5238(x64Operand& operand, int tokenPos) { operand.addressCoding = 436; } -x64Token x64Parser::tokenBranches5237[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5238, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4649(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5025(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5237(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3765[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3766, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3747(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4648[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4649, x64Parser::tokenBranches4649}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5025, x64Parser::tokenBranches5025}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5237, x64Parser::tokenBranches5237}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4818(x64Operand& operand, int tokenPos) { operand.addressCoding = 388; } -x64Token x64Parser::tokenBranches4636[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4637}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4648}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4818, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3320(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3412(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3504(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4636(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc3756(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3319[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4487}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3320, x64Parser::tokenBranches3320}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3412, x64Parser::tokenBranches3412}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3504, x64Parser::tokenBranches3504}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4636, x64Parser::tokenBranches4636}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4072(x64Operand& operand, int tokenPos) { operand.addressCoding = 330; } -x64Token x64Parser::tokenBranches4071[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4072, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4081(x64Operand& operand, int tokenPos) { operand.addressCoding = 331; } -x64Token x64Parser::tokenBranches4080[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4081, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4090(x64Operand& operand, int tokenPos) { operand.addressCoding = 332; } -x64Token x64Parser::tokenBranches4089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4071(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4080(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4089(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3765(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4070[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4071, x64Parser::tokenBranches4071}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4080, x64Parser::tokenBranches4080}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4089, x64Parser::tokenBranches4089}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4063(x64Operand& operand, int tokenPos) { operand.addressCoding = 330; } -x64Token x64Parser::tokenBranches4062[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4063, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4070}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4200(x64Operand& operand, int tokenPos) { operand.addressCoding = 339; } -x64Token x64Parser::tokenBranches4199[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4200, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4209(x64Operand& operand, int tokenPos) { operand.addressCoding = 340; } -x64Token x64Parser::tokenBranches4208[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4209, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4218(x64Operand& operand, int tokenPos) { operand.addressCoding = 341; } -x64Token x64Parser::tokenBranches4217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4199(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4208(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4217(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3746[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3747, x64Parser::tokenBranches3747 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3756, x64Parser::tokenBranches3756 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3765, x64Parser::tokenBranches3765 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3739(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches4198[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4199, x64Parser::tokenBranches4199}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4208, x64Parser::tokenBranches4208}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4217, x64Parser::tokenBranches4217}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4191(x64Operand& operand, int tokenPos) { operand.addressCoding = 339; } -x64Token x64Parser::tokenBranches4190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4191, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4274(x64Operand& operand, int tokenPos) { operand.addressCoding = 349; } -x64Token x64Parser::tokenBranches4273[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4274, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4273(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3738[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3739, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3746 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3876(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches4272[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4273, x64Parser::tokenBranches4273}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4265(x64Operand& operand, int tokenPos) { operand.addressCoding = 348; } -x64Token x64Parser::tokenBranches4264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4265, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4272}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4062(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4190(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4264(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3875[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3876, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3885(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 319; } -x64Token x64Parser::tokenBranches4061[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4062, x64Parser::tokenBranches4062}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4190, x64Parser::tokenBranches4190}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4264, x64Parser::tokenBranches4264}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3211(x64Operand& operand, int tokenPos) { operand.addressCoding = 251; } -x64Token x64Parser::tokenBranches3210[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3211, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3319}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4061}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3346(x64Operand& operand, int tokenPos) { operand.addressCoding = 257; } -x64Token x64Parser::tokenBranches3345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3438(x64Operand& operand, int tokenPos) { operand.addressCoding = 274; } -x64Token x64Parser::tokenBranches3437[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3438, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3530(x64Operand& operand, int tokenPos) { operand.addressCoding = 288; } -x64Token x64Parser::tokenBranches3529[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3530, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3345(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3437(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3529(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3884[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3885, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3894(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 320; } -x64Token x64Parser::tokenBranches3344[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3345, x64Parser::tokenBranches3345}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3437, x64Parser::tokenBranches3437}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3529, x64Parser::tokenBranches3529}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3243(x64Operand& operand, int tokenPos) { operand.addressCoding = 257; } -x64Token x64Parser::tokenBranches3242[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3243, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3344}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3328(x64Operand& operand, int tokenPos) { operand.addressCoding = 255; } -x64Token x64Parser::tokenBranches3327[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3328, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3420(x64Operand& operand, int tokenPos) { operand.addressCoding = 272; } -x64Token x64Parser::tokenBranches3419[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3420, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3512(x64Operand& operand, int tokenPos) { operand.addressCoding = 286; } -x64Token x64Parser::tokenBranches3511[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3512, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4661(x64Operand& operand, int tokenPos) { operand.addressCoding = 389; } -x64Token x64Parser::tokenBranches4660[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4661, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5037(x64Operand& operand, int tokenPos) { operand.addressCoding = 413; } -x64Token x64Parser::tokenBranches5036[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5037, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5249(x64Operand& operand, int tokenPos) { operand.addressCoding = 437; } -x64Token x64Parser::tokenBranches5248[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5249, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4660(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5036(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5248(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3893[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3894, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3875(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4659[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4660, x64Parser::tokenBranches4660}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5036, x64Parser::tokenBranches5036}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5248, x64Parser::tokenBranches5248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4827(x64Operand& operand, int tokenPos) { operand.addressCoding = 389; } -x64Token x64Parser::tokenBranches4658[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4659}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4827, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4658(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3884(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4657[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4658, x64Parser::tokenBranches4658}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4670(x64Operand& operand, int tokenPos) { operand.addressCoding = 390; } -x64Token x64Parser::tokenBranches4669[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4670, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5046(x64Operand& operand, int tokenPos) { operand.addressCoding = 414; } -x64Token x64Parser::tokenBranches5045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5046, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5258(x64Operand& operand, int tokenPos) { operand.addressCoding = 438; } -x64Token x64Parser::tokenBranches5257[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5258, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4669(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5045(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5257(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3893(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4668[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4669, x64Parser::tokenBranches4669}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5045, x64Parser::tokenBranches5045}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5257, x64Parser::tokenBranches5257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4834(x64Operand& operand, int tokenPos) { operand.addressCoding = 390; } -x64Token x64Parser::tokenBranches4656[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4657}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4668}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4834, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3327(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3419(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3511(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4656(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches3874[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3875, x64Parser::tokenBranches3875 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3884, x64Parser::tokenBranches3884 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3893, x64Parser::tokenBranches3893 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3867(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 318; +} +x64Token x64Parser::tokenBranches3866[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3867, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3874 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3738(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3866(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3241[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3242}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3327, x64Parser::tokenBranches3327}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3419, x64Parser::tokenBranches3419}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3511, x64Parser::tokenBranches3511}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4656, x64Parser::tokenBranches4656}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4316(x64Operand& operand, int tokenPos) { operand.addressCoding = 350; } -x64Token x64Parser::tokenBranches4315[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4316, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4325(x64Operand& operand, int tokenPos) { operand.addressCoding = 351; } -x64Token x64Parser::tokenBranches4324[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4325, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4334(x64Operand& operand, int tokenPos) { operand.addressCoding = 352; } -x64Token x64Parser::tokenBranches4333[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4334, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4315(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4324(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4333(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3737[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3738, x64Parser::tokenBranches3738 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3866, x64Parser::tokenBranches3866 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3736[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3737 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4004(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches4314[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4315, x64Parser::tokenBranches4315}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4324, x64Parser::tokenBranches4324}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4333, x64Parser::tokenBranches4333}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4307(x64Operand& operand, int tokenPos) { operand.addressCoding = 350; } -x64Token x64Parser::tokenBranches4306[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4307, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4314}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4376(x64Operand& operand, int tokenPos) { operand.addressCoding = 356; } -x64Token x64Parser::tokenBranches4375[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4376, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4385(x64Operand& operand, int tokenPos) { operand.addressCoding = 357; } -x64Token x64Parser::tokenBranches4384[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4385, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4394(x64Operand& operand, int tokenPos) { operand.addressCoding = 358; } -x64Token x64Parser::tokenBranches4393[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4394, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4375(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4384(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4393(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4003[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4004, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4013(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 328; } -x64Token x64Parser::tokenBranches4374[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4375, x64Parser::tokenBranches4375}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4384, x64Parser::tokenBranches4384}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4393, x64Parser::tokenBranches4393}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4367(x64Operand& operand, int tokenPos) { operand.addressCoding = 356; } -x64Token x64Parser::tokenBranches4366[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4367, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4374}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4438(x64Operand& operand, int tokenPos) { operand.addressCoding = 364; } -x64Token x64Parser::tokenBranches4437[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4438, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4458(x64Operand& operand, int tokenPos) { operand.addressCoding = 366; } -x64Token x64Parser::tokenBranches4457[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4458, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4457(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4012[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4013, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4022(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 329; } -x64Token x64Parser::tokenBranches4456[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4457, x64Parser::tokenBranches4457}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4447(x64Operand& operand, int tokenPos) { operand.addressCoding = 365; } -x64Token x64Parser::tokenBranches4446[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4447, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4456}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4437(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4021[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4022, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4003(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4436[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4446}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4437, x64Parser::tokenBranches4437}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4429(x64Operand& operand, int tokenPos) { operand.addressCoding = 363; } -x64Token x64Parser::tokenBranches4428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4429, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4436}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4306(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4366(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4428(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4012(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4305[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4306, x64Parser::tokenBranches4306}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4366, x64Parser::tokenBranches4366}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4428, x64Parser::tokenBranches4428}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3229(x64Operand& operand, int tokenPos) { operand.addressCoding = 255; } -x64Token x64Parser::tokenBranches3228[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3229, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3241}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3256(x64Operand& operand, int tokenPos) { operand.addressCoding = 260; } -x64Token x64Parser::tokenBranches3255[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3256, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc18(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc88(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc549(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc574(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3228(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc3255(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4021(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches17[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches61}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches68}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches490}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches495}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches500}, - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3195}, - {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3200}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3205}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3210}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc18, x64Parser::tokenBranches18}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc88, x64Parser::tokenBranches88}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc549, x64Parser::tokenBranches549}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc574, x64Parser::tokenBranches574}, - {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3228, x64Parser::tokenBranches3228}, - {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3255, x64Parser::tokenBranches3255}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches16[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches17}, - {x64Token::EOT}}; -void x64Parser::TokenFunc184(x64Operand& operand, int tokenPos) { operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches183[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc184, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc330(x64Operand& operand, int tokenPos) { operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches329[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc330, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc183(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc329(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4002[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4003, x64Parser::tokenBranches4003 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4012, x64Parser::tokenBranches4012 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4021, x64Parser::tokenBranches4021 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3995(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches182[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc183, x64Parser::tokenBranches183}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc329, x64Parser::tokenBranches329}, - {x64Token::EOT}}; -void x64Parser::TokenFunc24(x64Operand& operand, int tokenPos) { operand.addressCoding = 4; } -x64Token x64Parser::tokenBranches23[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc24, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches182}, - {x64Token::EOT}}; -void x64Parser::TokenFunc130(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc276(x64Operand& operand, int tokenPos) { operand.addressCoding = 28; } -x64Token x64Parser::tokenBranches275[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc276, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc422(x64Operand& operand, int tokenPos) { operand.addressCoding = 43; } -x64Token x64Parser::tokenBranches421[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc422, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc23(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc129(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc275(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc421(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3994[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3995, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4002 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4132(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches22[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc23, x64Parser::tokenBranches23}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc129, x64Parser::tokenBranches129}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc275, x64Parser::tokenBranches275}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc421, x64Parser::tokenBranches421}, - {x64Token::EOT}}; -void x64Parser::TokenFunc92(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches21[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches22}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc92, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc191(x64Operand& operand, int tokenPos) { operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc191, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc337(x64Operand& operand, int tokenPos) { operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches336[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc337, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc190(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc336(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4131[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4132, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4141(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 337; } -x64Token x64Parser::tokenBranches189[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc190, x64Parser::tokenBranches190}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc336, x64Parser::tokenBranches336}, - {x64Token::EOT}}; -void x64Parser::TokenFunc29(x64Operand& operand, int tokenPos) { operand.addressCoding = 5; } -x64Token x64Parser::tokenBranches28[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc29, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches189}, - {x64Token::EOT}}; -void x64Parser::TokenFunc156(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches155[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc156, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc302(x64Operand& operand, int tokenPos) { operand.addressCoding = 31; } -x64Token x64Parser::tokenBranches301[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc302, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc448(x64Operand& operand, int tokenPos) { operand.addressCoding = 46; } -x64Token x64Parser::tokenBranches447[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc448, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc28(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc155(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc301(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc447(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4140[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4141, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 338; } -x64Token x64Parser::tokenBranches27[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc28, x64Parser::tokenBranches28}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc155, x64Parser::tokenBranches155}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc301, x64Parser::tokenBranches301}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc447, x64Parser::tokenBranches447}, - {x64Token::EOT}}; -void x64Parser::TokenFunc110(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches26[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches27}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc250(x64Operand& operand, int tokenPos) { operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches249[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc250, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc396(x64Operand& operand, int tokenPos) { operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches395[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc396, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc249(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc395(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4150, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4131(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches248[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc249, x64Parser::tokenBranches249}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc395, x64Parser::tokenBranches395}, - {x64Token::EOT}}; -void x64Parser::TokenFunc74(x64Operand& operand, int tokenPos) { operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches73[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc74, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc580(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches579[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc580, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc690(x64Operand& operand, int tokenPos) { operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches689[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc690, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc814(x64Operand& operand, int tokenPos) { operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches813[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc814, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2083(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2082[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2083, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2615(x64Operand& operand, int tokenPos) { operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2614[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2615, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2913(x64Operand& operand, int tokenPos) { operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches2912[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2913, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2082(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2614(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2912(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4140(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2081[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2082, x64Parser::tokenBranches2082}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2614, x64Parser::tokenBranches2614}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2912, x64Parser::tokenBranches2912}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2373(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2080[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2081}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2373, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2080(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4149(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2079[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2080, x64Parser::tokenBranches2080}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2090(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2622(x64Operand& operand, int tokenPos) { operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches2621[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2622, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2920(x64Operand& operand, int tokenPos) { operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches2919[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2920, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2089(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2621(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2919(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4130[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4131, x64Parser::tokenBranches4131 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4140, x64Parser::tokenBranches4140 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4149, x64Parser::tokenBranches4149 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4123(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 336; +} +x64Token x64Parser::tokenBranches4122[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4123, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4130 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3994(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4122(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2088[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2089, x64Parser::tokenBranches2089}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2621, x64Parser::tokenBranches2621}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2919, x64Parser::tokenBranches2919}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2378(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2078[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2079}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2088}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2378, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc579(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc689(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc813(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2078(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches3993[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3994, x64Parser::tokenBranches3994 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4122, x64Parser::tokenBranches4122 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3992[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3993 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc78(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc525(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc564(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches578[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc579, x64Parser::tokenBranches579}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc689, x64Parser::tokenBranches689}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc813, x64Parser::tokenBranches813}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2078, x64Parser::tokenBranches2078}, - {x64Token::EOT}}; -void x64Parser::TokenFunc472(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches471[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc472, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches578}, - {x64Token::EOT}}; -void x64Parser::TokenFunc585(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches584[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc585, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc695(x64Operand& operand, int tokenPos) { operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches694[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc695, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc819(x64Operand& operand, int tokenPos) { operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches818[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc819, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2058(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2057[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2058, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2590(x64Operand& operand, int tokenPos) { operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches2589[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2590, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2888(x64Operand& operand, int tokenPos) { operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches2887[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2888, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2057(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2589(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2887(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches33 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches54 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches505 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches510 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1219 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3736 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3992 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc8, x64Parser::tokenBranches8 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc78, x64Parser::tokenBranches78 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc525, x64Parser::tokenBranches525 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc564, x64Parser::tokenBranches564 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches7 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc14(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 2; +} +x64Token x64Parser::tokenBranches13[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc14, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc209(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 21; +} +x64Token x64Parser::tokenBranches208[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc209, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc355(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 36; +} +x64Token x64Parser::tokenBranches354[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc355, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc208(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc354(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2056[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2057, x64Parser::tokenBranches2057}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2589, x64Parser::tokenBranches2589}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2887, x64Parser::tokenBranches2887}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2354(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2055[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2056}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2354, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2067(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2066[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2067, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2599(x64Operand& operand, int tokenPos) { operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches2598[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2599, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2897(x64Operand& operand, int tokenPos) { operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2896[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2897, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2066(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2598(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2896(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches207[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc208, x64Parser::tokenBranches208 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc354, x64Parser::tokenBranches354 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc43(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 6; +} +x64Token x64Parser::tokenBranches42[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc43, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches207 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc144(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 14; +} +x64Token x64Parser::tokenBranches143[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc144, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 29; +} +x64Token x64Parser::tokenBranches289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc290, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc436(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 44; +} +x64Token x64Parser::tokenBranches435[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc436, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc42(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc143(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc289(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc435(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2065[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2066, x64Parser::tokenBranches2066}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2598, x64Parser::tokenBranches2598}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2896, x64Parser::tokenBranches2896}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2361(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2064[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2065}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2361, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2064(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches41[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc42, x64Parser::tokenBranches42 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc143, x64Parser::tokenBranches143 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc289, x64Parser::tokenBranches289 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc435, x64Parser::tokenBranches435 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc102(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches2063[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2064, x64Parser::tokenBranches2064}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2074(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2073[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2074, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2606(x64Operand& operand, int tokenPos) { operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches2605[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2606, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2904(x64Operand& operand, int tokenPos) { operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches2903[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2904, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2073(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2605(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2903(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches40[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches41 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc102, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches2072[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2073, x64Parser::tokenBranches2073}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2605, x64Parser::tokenBranches2605}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2903, x64Parser::tokenBranches2903}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2366(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2062[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2063}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2072}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2366, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc584(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc694(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc818(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2062(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc364(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches583[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2055}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc584, x64Parser::tokenBranches584}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc694, x64Parser::tokenBranches694}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc818, x64Parser::tokenBranches818}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2062, x64Parser::tokenBranches2062}, - {x64Token::EOT}}; -void x64Parser::TokenFunc945(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc952(x64Operand& operand, int tokenPos) { operand.addressCoding = 97; } -x64Token x64Parser::tokenBranches951[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc952, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc959(x64Operand& operand, int tokenPos) { operand.addressCoding = 98; } -x64Token x64Parser::tokenBranches958[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc959, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc944(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc951(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc958(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches363[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc364, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc217(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches943[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc944, x64Parser::tokenBranches944}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc951, x64Parser::tokenBranches951}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc958, x64Parser::tokenBranches958}, - {x64Token::EOT}}; -void x64Parser::TokenFunc938(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches937[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc938, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches943}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1073(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1072[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1073, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1080(x64Operand& operand, int tokenPos) { operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches1079[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1080, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1087(x64Operand& operand, int tokenPos) { operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches1086[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1087, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1072(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1079(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1086(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc363(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1071[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1072, x64Parser::tokenBranches1072}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1079, x64Parser::tokenBranches1079}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1086, x64Parser::tokenBranches1086}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1066(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1065[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1066, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1071}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1457(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1456[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1457, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1464(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1463[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1464, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1456(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1463(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches216[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc217, x64Parser::tokenBranches217 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc363, x64Parser::tokenBranches363 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc50(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 5; +} +x64Token x64Parser::tokenBranches49[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc50, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches216 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc163(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches162[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc163, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc309(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 31; +} +x64Token x64Parser::tokenBranches308[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc309, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc455(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 46; +} +x64Token x64Parser::tokenBranches454[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc455, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc49(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc162(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc308(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc454(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1455[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1456, x64Parser::tokenBranches1456}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1463, x64Parser::tokenBranches1463}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1450(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1449[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1450, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1455}, - {x64Token::EOT}}; -void x64Parser::TokenFunc937(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1065(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1449(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches48[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc49, x64Parser::tokenBranches49 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc162, x64Parser::tokenBranches162 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc308, x64Parser::tokenBranches308 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc454, x64Parser::tokenBranches454 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc115(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches936[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc937, x64Parser::tokenBranches937}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1065, x64Parser::tokenBranches1065}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1449, x64Parser::tokenBranches1449}, - {x64Token::EOT}}; -void x64Parser::TokenFunc475(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches474[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc475, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches583}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches936}, - {x64Token::EOT}}; -void x64Parser::TokenFunc618(x64Operand& operand, int tokenPos) { operand.addressCoding = 51; } -x64Token x64Parser::tokenBranches617[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc618, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc742(x64Operand& operand, int tokenPos) { operand.addressCoding = 74; } -x64Token x64Parser::tokenBranches741[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc742, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc866(x64Operand& operand, int tokenPos) { operand.addressCoding = 88; } -x64Token x64Parser::tokenBranches865[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc866, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2246(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2245[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2778(x64Operand& operand, int tokenPos) { operand.addressCoding = 208; } -x64Token x64Parser::tokenBranches2777[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3076(x64Operand& operand, int tokenPos) { operand.addressCoding = 234; } -x64Token x64Parser::tokenBranches3075[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3076, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2245(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2777(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3075(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches47[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches48 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc115, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc264(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 26; } -x64Token x64Parser::tokenBranches2244[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2245, x64Parser::tokenBranches2245}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2777, x64Parser::tokenBranches2777}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3075, x64Parser::tokenBranches3075}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2502(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2243[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2244}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2502, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2243(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches263[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc264, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc410(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 41; } -x64Token x64Parser::tokenBranches2242[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2243, x64Parser::tokenBranches2243}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2253(x64Operand& operand, int tokenPos) { operand.addressCoding = 184; } -x64Token x64Parser::tokenBranches2252[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2253, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2785(x64Operand& operand, int tokenPos) { operand.addressCoding = 209; } -x64Token x64Parser::tokenBranches2784[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2785, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3083(x64Operand& operand, int tokenPos) { operand.addressCoding = 235; } -x64Token x64Parser::tokenBranches3082[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3083, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2252(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2784(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3082(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches409[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc410, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc263(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2251[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2252, x64Parser::tokenBranches2252}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2784, x64Parser::tokenBranches2784}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3082, x64Parser::tokenBranches3082}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2507(x64Operand& operand, int tokenPos) { operand.addressCoding = 184; } -x64Token x64Parser::tokenBranches2241[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2242}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2251}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2507, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc617(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc741(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc865(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2241(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc409(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches616[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc617, x64Parser::tokenBranches617}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc741, x64Parser::tokenBranches741}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc865, x64Parser::tokenBranches865}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2241, x64Parser::tokenBranches2241}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1201(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1200[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1201, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1208(x64Operand& operand, int tokenPos) { operand.addressCoding = 115; } -x64Token x64Parser::tokenBranches1207[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1208, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1215(x64Operand& operand, int tokenPos) { operand.addressCoding = 116; } -x64Token x64Parser::tokenBranches1214[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1215, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1200(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1207(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1214(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches262[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc263, x64Parser::tokenBranches263 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc409, x64Parser::tokenBranches409 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc84(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 11; } -x64Token x64Parser::tokenBranches1199[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1200, x64Parser::tokenBranches1200}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1207, x64Parser::tokenBranches1207}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1214, x64Parser::tokenBranches1214}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1194(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1193[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1194, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1199}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1329(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1328[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1329, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1336(x64Operand& operand, int tokenPos) { operand.addressCoding = 124; } -x64Token x64Parser::tokenBranches1335[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1336, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1343(x64Operand& operand, int tokenPos) { operand.addressCoding = 125; } -x64Token x64Parser::tokenBranches1342[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1343, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1328(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1335(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1342(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches83[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc84, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches262 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc592(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches1327[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1328, x64Parser::tokenBranches1328}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1335, x64Parser::tokenBranches1335}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1342, x64Parser::tokenBranches1342}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1322(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1321[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1322, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1327}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1551(x64Operand& operand, int tokenPos) { operand.addressCoding = 138; } -x64Token x64Parser::tokenBranches1550[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1558(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1557[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1558, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1550(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1557(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches591[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc592, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc716(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches1549[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1550, x64Parser::tokenBranches1550}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1557, x64Parser::tokenBranches1557}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1544(x64Operand& operand, int tokenPos) { operand.addressCoding = 138; } -x64Token x64Parser::tokenBranches1543[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1544, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1549}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1193(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1321(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1543(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches715[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc716, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc840(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches1192[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1193, x64Parser::tokenBranches1193}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1321, x64Parser::tokenBranches1321}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1543, x64Parser::tokenBranches1543}, - {x64Token::EOT}}; -void x64Parser::TokenFunc478(x64Operand& operand, int tokenPos) { operand.addressCoding = 51; } -x64Token x64Parser::tokenBranches477[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc478, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches616}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1192}, - {x64Token::EOT}}; -void x64Parser::TokenFunc630(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches629[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc630, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc754(x64Operand& operand, int tokenPos) { operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches753[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc754, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc878(x64Operand& operand, int tokenPos) { operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches877[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc878, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc629(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc753(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc877(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches839[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc840, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2161(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches628[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc629, x64Parser::tokenBranches629}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc753, x64Parser::tokenBranches753}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc877, x64Parser::tokenBranches877}, - {x64Token::EOT}}; -void x64Parser::TokenFunc486(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches485[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc486, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches628}, - {x64Token::EOT}}; -void x64Parser::TokenFunc623(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc623, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc747(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches746[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc747, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc871(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches870[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2262(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2261[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2262, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2794(x64Operand& operand, int tokenPos) { operand.addressCoding = 210; } -x64Token x64Parser::tokenBranches2793[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2794, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3092(x64Operand& operand, int tokenPos) { operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches3091[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3092, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2261(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2793(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3091(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2160[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2161, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2720(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2260[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2261, x64Parser::tokenBranches2261}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2793, x64Parser::tokenBranches2793}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3091, x64Parser::tokenBranches3091}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2514(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2259[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2260}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2514, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2259(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2719[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2720, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2991(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 226; } -x64Token x64Parser::tokenBranches2258[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2259, x64Parser::tokenBranches2259}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2269(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2268[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2269, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2801(x64Operand& operand, int tokenPos) { operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches2800[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2801, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3099(x64Operand& operand, int tokenPos) { operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches3098[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3099, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2268(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2800(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3098(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2990[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2991, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2160(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2267[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2268, x64Parser::tokenBranches2268}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2800, x64Parser::tokenBranches2800}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3098, x64Parser::tokenBranches3098}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2519(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2257[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2258}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2267}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2519, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc622(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc746(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc870(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2257(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2719(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches484[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches485}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc622, x64Parser::tokenBranches622}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc746, x64Parser::tokenBranches746}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc870, x64Parser::tokenBranches870}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2257, x64Parser::tokenBranches2257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1595(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1594[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1595, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1602(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches1601[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1602, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1609(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches1608[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1609, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1594(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1601(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1608(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2990(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1593[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1594, x64Parser::tokenBranches1594}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1601, x64Parser::tokenBranches1601}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1608, x64Parser::tokenBranches1608}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1588(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1587[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1588, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1593}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1723(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1722[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1723, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1730(x64Operand& operand, int tokenPos) { operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches1729[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1737(x64Operand& operand, int tokenPos) { operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1736[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1737, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1722(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1729(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1736(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2159[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2160, x64Parser::tokenBranches2160 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2719, x64Parser::tokenBranches2719 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2990, x64Parser::tokenBranches2990 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2435(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches1721[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1722, x64Parser::tokenBranches1722}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1729, x64Parser::tokenBranches1729}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1736, x64Parser::tokenBranches1736}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1716(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1715[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1716, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1721}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1851(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1850[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1851, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1858(x64Operand& operand, int tokenPos) { operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches1857[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1858, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1874(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1873[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1874, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1883(x64Operand& operand, int tokenPos) { operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches1882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1883, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1873(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1882(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2158[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2159 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2435, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2158(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1872[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1873, x64Parser::tokenBranches1873}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1882, x64Parser::tokenBranches1882}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1865(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1864[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1865, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1872}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1850(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1857(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2157[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2158, x64Parser::tokenBranches2158 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches1849[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1864}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1850, x64Parser::tokenBranches1850}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1857, x64Parser::tokenBranches1857}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1844(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1843[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1844, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1849}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1587(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1715(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1843(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2729(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches1586[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1587, x64Parser::tokenBranches1587}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1715, x64Parser::tokenBranches1715}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1843, x64Parser::tokenBranches1843}, - {x64Token::EOT}}; -void x64Parser::TokenFunc481(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches480[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc481, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches484}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1586}, - {x64Token::EOT}}; -void x64Parser::TokenFunc560(x64Operand& operand, int tokenPos) { operand.addressCoding = 63; } -x64Token x64Parser::tokenBranches559[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3261(x64Operand& operand, int tokenPos) { operand.addressCoding = 244; } -x64Token x64Parser::tokenBranches3260[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3261, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3351(x64Operand& operand, int tokenPos) { operand.addressCoding = 261; } -x64Token x64Parser::tokenBranches3350[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3351, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3443(x64Operand& operand, int tokenPos) { operand.addressCoding = 275; } -x64Token x64Parser::tokenBranches3442[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3443, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4515(x64Operand& operand, int tokenPos) { operand.addressCoding = 373; } -x64Token x64Parser::tokenBranches4514[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4515, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4891(x64Operand& operand, int tokenPos) { operand.addressCoding = 397; } -x64Token x64Parser::tokenBranches4890[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4891, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5103(x64Operand& operand, int tokenPos) { operand.addressCoding = 421; } -x64Token x64Parser::tokenBranches5102[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5103, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4514(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4890(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5102(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2728[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2729, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3000(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 227; } -x64Token x64Parser::tokenBranches4513[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4514, x64Parser::tokenBranches4514}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4890, x64Parser::tokenBranches4890}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5102, x64Parser::tokenBranches5102}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4713(x64Operand& operand, int tokenPos) { operand.addressCoding = 373; } -x64Token x64Parser::tokenBranches4512[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4513}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4713, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4512(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2999[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3000, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2169(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4511[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4512, x64Parser::tokenBranches4512}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4522(x64Operand& operand, int tokenPos) { operand.addressCoding = 374; } -x64Token x64Parser::tokenBranches4521[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4522, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4898(x64Operand& operand, int tokenPos) { operand.addressCoding = 398; } -x64Token x64Parser::tokenBranches4897[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4898, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5110(x64Operand& operand, int tokenPos) { operand.addressCoding = 422; } -x64Token x64Parser::tokenBranches5109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4521(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4897(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5109(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2728(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4520[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4521, x64Parser::tokenBranches4521}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4897, x64Parser::tokenBranches4897}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5109, x64Parser::tokenBranches5109}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4718(x64Operand& operand, int tokenPos) { operand.addressCoding = 374; } -x64Token x64Parser::tokenBranches4510[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4511}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4520}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4718, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3260(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3350(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3442(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4510(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2999(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3259[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3260, x64Parser::tokenBranches3260}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3350, x64Parser::tokenBranches3350}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3442, x64Parser::tokenBranches3442}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4510, x64Parser::tokenBranches4510}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3182(x64Operand& operand, int tokenPos) { operand.addressCoding = 244; } -x64Token x64Parser::tokenBranches3181[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3182, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3259}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3307(x64Operand& operand, int tokenPos) { operand.addressCoding = 253; } -x64Token x64Parser::tokenBranches3306[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3307, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3399(x64Operand& operand, int tokenPos) { operand.addressCoding = 269; } -x64Token x64Parser::tokenBranches3398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3399, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3491(x64Operand& operand, int tokenPos) { operand.addressCoding = 283; } -x64Token x64Parser::tokenBranches3490[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3491, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3306(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3398(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3490(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2168[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2169, x64Parser::tokenBranches2169 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2728, x64Parser::tokenBranches2728 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2999, x64Parser::tokenBranches2999 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2442(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2156[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2157 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2168 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2442, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc591(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc715(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc839(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2156(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches3305[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3306, x64Parser::tokenBranches3306}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3398, x64Parser::tokenBranches3398}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3490, x64Parser::tokenBranches3490}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3219(x64Operand& operand, int tokenPos) { operand.addressCoding = 253; } -x64Token x64Parser::tokenBranches3218[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3219, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3356(x64Operand& operand, int tokenPos) { operand.addressCoding = 262; } -x64Token x64Parser::tokenBranches3355[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3356, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3448(x64Operand& operand, int tokenPos) { operand.addressCoding = 276; } -x64Token x64Parser::tokenBranches3447[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3448, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4531(x64Operand& operand, int tokenPos) { operand.addressCoding = 375; } -x64Token x64Parser::tokenBranches4530[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4531, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4907(x64Operand& operand, int tokenPos) { operand.addressCoding = 399; } -x64Token x64Parser::tokenBranches4906[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4907, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5119(x64Operand& operand, int tokenPos) { operand.addressCoding = 423; } -x64Token x64Parser::tokenBranches5118[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5119, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4530(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4906(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5118(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches590[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc591, x64Parser::tokenBranches591 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc715, x64Parser::tokenBranches715 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc839, x64Parser::tokenBranches839 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2156, x64Parser::tokenBranches2156 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc516(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches4529[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4530, x64Parser::tokenBranches4530}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4906, x64Parser::tokenBranches4906}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5118, x64Parser::tokenBranches5118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4725(x64Operand& operand, int tokenPos) { operand.addressCoding = 375; } -x64Token x64Parser::tokenBranches4528[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4529}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4725, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4528(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches515[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc516, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches590 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc599(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches4527[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4528, x64Parser::tokenBranches4528}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4538(x64Operand& operand, int tokenPos) { operand.addressCoding = 376; } -x64Token x64Parser::tokenBranches4537[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4538, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4914(x64Operand& operand, int tokenPos) { operand.addressCoding = 400; } -x64Token x64Parser::tokenBranches4913[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4914, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5126(x64Operand& operand, int tokenPos) { operand.addressCoding = 424; } -x64Token x64Parser::tokenBranches5125[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5126, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4537(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4913(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5125(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches598[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc599, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc723(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches4536[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4537, x64Parser::tokenBranches4537}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4913, x64Parser::tokenBranches4913}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5125, x64Parser::tokenBranches5125}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4730(x64Operand& operand, int tokenPos) { operand.addressCoding = 376; } -x64Token x64Parser::tokenBranches4526[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4527}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4536}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3355(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3447(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4526(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches722[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc723, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc847(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches3217[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3218}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3355, x64Parser::tokenBranches3355}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3447, x64Parser::tokenBranches3447}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4526, x64Parser::tokenBranches4526}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3265(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3265, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3542(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3541[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3542, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3549(x64Operand& operand, int tokenPos) { operand.addressCoding = 262; } -x64Token x64Parser::tokenBranches3548[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3549, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3556(x64Operand& operand, int tokenPos) { operand.addressCoding = 276; } -x64Token x64Parser::tokenBranches3555[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3556, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3541(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3548(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3555(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches846[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc847, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2141(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches3540[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3541, x64Parser::tokenBranches3541}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3548, x64Parser::tokenBranches3548}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3555, x64Parser::tokenBranches3555}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3535(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3534[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3535, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3540}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3602(x64Operand& operand, int tokenPos) { operand.addressCoding = 292; } -x64Token x64Parser::tokenBranches3601[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3602, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3609(x64Operand& operand, int tokenPos) { operand.addressCoding = 293; } -x64Token x64Parser::tokenBranches3608[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3609, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3616(x64Operand& operand, int tokenPos) { operand.addressCoding = 294; } -x64Token x64Parser::tokenBranches3615[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3616, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3601(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3608(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3615(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2140[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2141, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2700(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches3600[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3601, x64Parser::tokenBranches3601}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3608, x64Parser::tokenBranches3608}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3615, x64Parser::tokenBranches3615}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3595(x64Operand& operand, int tokenPos) { operand.addressCoding = 292; } -x64Token x64Parser::tokenBranches3594[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3595, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3600}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3662(x64Operand& operand, int tokenPos) { operand.addressCoding = 299; } -x64Token x64Parser::tokenBranches3661[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3662, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3661(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2699[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2700, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2971(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 224; } -x64Token x64Parser::tokenBranches3660[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3661, x64Parser::tokenBranches3661}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3655(x64Operand& operand, int tokenPos) { operand.addressCoding = 298; } -x64Token x64Parser::tokenBranches3654[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3655, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3660}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3690(x64Operand& operand, int tokenPos) { operand.addressCoding = 303; } -x64Token x64Parser::tokenBranches3689[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3690, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3689(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2970[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2971, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2140(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3688[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3689, x64Parser::tokenBranches3689}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3683(x64Operand& operand, int tokenPos) { operand.addressCoding = 302; } -x64Token x64Parser::tokenBranches3682[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3683, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3688}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3534(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3594(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3654(x64Operand& operand, int tokenPos) -{ - operand.values[13] = new Coding[2]; - CleanupValues.push_back(operand.values[13]); - operand.values[13]->type = Coding::number; - operand.values[13]->val = operands.size(); - operand.values[13]->bits = 0; - operand.values[13]->field = 0; - operand.values[13]->unary = 0; - operand.values[13]->binary = 0; - operand.values[13][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3682(x64Operand& operand, int tokenPos) -{ - operand.values[14] = new Coding[2]; - CleanupValues.push_back(operand.values[14]); - operand.values[14]->type = Coding::number; - operand.values[14]->val = operands.size(); - operand.values[14]->bits = 0; - operand.values[14]->field = 0; - operand.values[14]->unary = 0; - operand.values[14]->binary = 0; - operand.values[14][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2699(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3533[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3534, x64Parser::tokenBranches3534}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3594, x64Parser::tokenBranches3594}, - {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3654, x64Parser::tokenBranches3654}, - {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3682, x64Parser::tokenBranches3682}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3185(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -void x64Parser::TokenFunc3264(x64Operand& operand, int tokenPos) -{ - operand.values[12] = new Coding[2]; - CleanupValues.push_back(operand.values[12]); - operand.values[12]->type = Coding::number; - operand.values[12]->val = operands.size(); - operand.values[12]->bits = 0; - operand.values[12]->field = 0; - operand.values[12]->unary = 0; - operand.values[12]->binary = 0; - operand.values[12][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2970(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3184[] = { - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3185, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3217}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3264, x64Parser::tokenBranches3264}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3533}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3270(x64Operand& operand, int tokenPos) { operand.addressCoding = 246; } -x64Token x64Parser::tokenBranches3269[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3270, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3361(x64Operand& operand, int tokenPos) { operand.addressCoding = 263; } -x64Token x64Parser::tokenBranches3360[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3361, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3453(x64Operand& operand, int tokenPos) { operand.addressCoding = 277; } -x64Token x64Parser::tokenBranches3452[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3453, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4465(x64Operand& operand, int tokenPos) { operand.addressCoding = 367; } -x64Token x64Parser::tokenBranches4464[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4465, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4841(x64Operand& operand, int tokenPos) { operand.addressCoding = 391; } -x64Token x64Parser::tokenBranches4840[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4841, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5053(x64Operand& operand, int tokenPos) { operand.addressCoding = 415; } -x64Token x64Parser::tokenBranches5052[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5053, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4464(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4840(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5052(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2139[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2140, x64Parser::tokenBranches2140 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2699, x64Parser::tokenBranches2699 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2970, x64Parser::tokenBranches2970 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2419(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches4463[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4464, x64Parser::tokenBranches4464}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4840, x64Parser::tokenBranches4840}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5052, x64Parser::tokenBranches5052}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4675(x64Operand& operand, int tokenPos) { operand.addressCoding = 367; } -x64Token x64Parser::tokenBranches4462[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4463}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4675, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4499(x64Operand& operand, int tokenPos) { operand.addressCoding = 371; } -x64Token x64Parser::tokenBranches4498[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4499, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4875(x64Operand& operand, int tokenPos) { operand.addressCoding = 395; } -x64Token x64Parser::tokenBranches4874[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4875, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5087(x64Operand& operand, int tokenPos) { operand.addressCoding = 419; } -x64Token x64Parser::tokenBranches5086[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5087, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4498(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4874(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5086(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2138[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2139 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2419, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2138(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4497[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4498, x64Parser::tokenBranches4498}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4874, x64Parser::tokenBranches4874}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5086, x64Parser::tokenBranches5086}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4701(x64Operand& operand, int tokenPos) { operand.addressCoding = 371; } -x64Token x64Parser::tokenBranches4496[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4497}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4701, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4496(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2137[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2138, x64Parser::tokenBranches2138 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches4495[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4496, x64Parser::tokenBranches4496}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4506(x64Operand& operand, int tokenPos) { operand.addressCoding = 372; } -x64Token x64Parser::tokenBranches4505[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4506, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4882(x64Operand& operand, int tokenPos) { operand.addressCoding = 396; } -x64Token x64Parser::tokenBranches4881[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4882, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5094(x64Operand& operand, int tokenPos) { operand.addressCoding = 420; } -x64Token x64Parser::tokenBranches5093[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5094, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4505(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4881(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5093(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2150, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2709(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches4504[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4505, x64Parser::tokenBranches4505}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4881, x64Parser::tokenBranches4881}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5093, x64Parser::tokenBranches5093}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4706(x64Operand& operand, int tokenPos) { operand.addressCoding = 372; } -x64Token x64Parser::tokenBranches4494[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4495}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4504}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4706, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3269(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3360(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3452(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4494(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2708[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2709, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2980(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 225; } -x64Token x64Parser::tokenBranches3268[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4462}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3269, x64Parser::tokenBranches3269}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3360, x64Parser::tokenBranches3360}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3452, x64Parser::tokenBranches3452}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4494, x64Parser::tokenBranches4494}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3718(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3717[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3718, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3725(x64Operand& operand, int tokenPos) { operand.addressCoding = 307; } -x64Token x64Parser::tokenBranches3724[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3725, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3732(x64Operand& operand, int tokenPos) { operand.addressCoding = 308; } -x64Token x64Parser::tokenBranches3731[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3732, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3717(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3724(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3731(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2979[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2980, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2149(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3716[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3717, x64Parser::tokenBranches3717}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3724, x64Parser::tokenBranches3724}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3731, x64Parser::tokenBranches3731}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3711(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3710[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3711, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3716}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3846(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3845[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3846, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3853(x64Operand& operand, int tokenPos) { operand.addressCoding = 316; } -x64Token x64Parser::tokenBranches3852[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3853, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3860(x64Operand& operand, int tokenPos) { operand.addressCoding = 317; } -x64Token x64Parser::tokenBranches3859[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3860, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3845(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3852(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3859(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2708(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3844[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3845, x64Parser::tokenBranches3845}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3852, x64Parser::tokenBranches3852}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3859, x64Parser::tokenBranches3859}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3839(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3838[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3839, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3844}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4230(x64Operand& operand, int tokenPos) { operand.addressCoding = 343; } -x64Token x64Parser::tokenBranches4229[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4230, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4229(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2979(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4228[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4229, x64Parser::tokenBranches4229}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4223(x64Operand& operand, int tokenPos) { operand.addressCoding = 342; } -x64Token x64Parser::tokenBranches4222[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4223, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4228}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3710(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3838(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4222(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2148[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2149, x64Parser::tokenBranches2149 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2708, x64Parser::tokenBranches2708 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2979, x64Parser::tokenBranches2979 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2426(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches3709[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3710, x64Parser::tokenBranches3710}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3838, x64Parser::tokenBranches3838}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4222, x64Parser::tokenBranches4222}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3188(x64Operand& operand, int tokenPos) { operand.addressCoding = 246; } -x64Token x64Parser::tokenBranches3187[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3188, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3268}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3709}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3295(x64Operand& operand, int tokenPos) { operand.addressCoding = 247; } -x64Token x64Parser::tokenBranches3294[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3295, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3387(x64Operand& operand, int tokenPos) { operand.addressCoding = 267; } -x64Token x64Parser::tokenBranches3386[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3479(x64Operand& operand, int tokenPos) { operand.addressCoding = 281; } -x64Token x64Parser::tokenBranches3478[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3479, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4472(x64Operand& operand, int tokenPos) { operand.addressCoding = 368; } -x64Token x64Parser::tokenBranches4471[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4472, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4848(x64Operand& operand, int tokenPos) { operand.addressCoding = 392; } -x64Token x64Parser::tokenBranches4847[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4848, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5060(x64Operand& operand, int tokenPos) { operand.addressCoding = 416; } -x64Token x64Parser::tokenBranches5059[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5060, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4471(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4847(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5059(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2136[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2137 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2148 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2426, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2228(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches4470[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4471, x64Parser::tokenBranches4471}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4847, x64Parser::tokenBranches4847}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5059, x64Parser::tokenBranches5059}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4680(x64Operand& operand, int tokenPos) { operand.addressCoding = 368; } -x64Token x64Parser::tokenBranches4469[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4470}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4680, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4607(x64Operand& operand, int tokenPos) { operand.addressCoding = 383; } -x64Token x64Parser::tokenBranches4606[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4607, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4983(x64Operand& operand, int tokenPos) { operand.addressCoding = 407; } -x64Token x64Parser::tokenBranches4982[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4983, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5195(x64Operand& operand, int tokenPos) { operand.addressCoding = 431; } -x64Token x64Parser::tokenBranches5194[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5195, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4606(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4982(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5194(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2227[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2228, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2640(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches4605[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4606, x64Parser::tokenBranches4606}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4982, x64Parser::tokenBranches4982}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5194, x64Parser::tokenBranches5194}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4785(x64Operand& operand, int tokenPos) { operand.addressCoding = 383; } -x64Token x64Parser::tokenBranches4604[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4605}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4785, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4604(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2639[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2640, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3018(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches4603[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4604, x64Parser::tokenBranches4604}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4614(x64Operand& operand, int tokenPos) { operand.addressCoding = 384; } -x64Token x64Parser::tokenBranches4613[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4614, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4990(x64Operand& operand, int tokenPos) { operand.addressCoding = 408; } -x64Token x64Parser::tokenBranches4989[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4990, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5202(x64Operand& operand, int tokenPos) { operand.addressCoding = 432; } -x64Token x64Parser::tokenBranches5201[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5202, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4613(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4989(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5201(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3017[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3018, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2227(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4612[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4613, x64Parser::tokenBranches4613}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4989, x64Parser::tokenBranches4989}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5201, x64Parser::tokenBranches5201}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4790(x64Operand& operand, int tokenPos) { operand.addressCoding = 384; } -x64Token x64Parser::tokenBranches4602[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4603}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4612}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4790, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3294(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3386(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3478(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4602(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2639(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3293[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4469}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3294, x64Parser::tokenBranches3294}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3386, x64Parser::tokenBranches3386}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3478, x64Parser::tokenBranches3478}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4602, x64Parser::tokenBranches4602}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3974(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches3973[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3974, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3981(x64Operand& operand, int tokenPos) { operand.addressCoding = 325; } -x64Token x64Parser::tokenBranches3980[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3981, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3988(x64Operand& operand, int tokenPos) { operand.addressCoding = 326; } -x64Token x64Parser::tokenBranches3987[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3988, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3973(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3980(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3987(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3017(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3972[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3973, x64Parser::tokenBranches3973}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3980, x64Parser::tokenBranches3980}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3987, x64Parser::tokenBranches3987}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3967(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches3966[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3967, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3972}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4102(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4101[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4109(x64Operand& operand, int tokenPos) { operand.addressCoding = 334; } -x64Token x64Parser::tokenBranches4108[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4109, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4116(x64Operand& operand, int tokenPos) { operand.addressCoding = 335; } -x64Token x64Parser::tokenBranches4115[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4116, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4101(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4108(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4115(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2226[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2227, x64Parser::tokenBranches2227 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2639, x64Parser::tokenBranches2639 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3017, x64Parser::tokenBranches3017 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2456(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2225[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2226 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2456, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc598(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc722(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc846(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2136(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches4100[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4101, x64Parser::tokenBranches4101}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4108, x64Parser::tokenBranches4108}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4115, x64Parser::tokenBranches4115}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4095(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4094[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4095, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4100}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4258(x64Operand& operand, int tokenPos) { operand.addressCoding = 347; } -x64Token x64Parser::tokenBranches4257[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4258, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4257(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches597[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2225 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc598, x64Parser::tokenBranches598 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc722, x64Parser::tokenBranches722 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc846, x64Parser::tokenBranches846 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2136, x64Parser::tokenBranches2136 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1009(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches1008[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1009, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1018(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 97; +} +x64Token x64Parser::tokenBranches1017[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1018, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1027(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 98; +} +x64Token x64Parser::tokenBranches1026[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1027, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1008(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1017(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1026(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4256[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4257, x64Parser::tokenBranches4257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4251(x64Operand& operand, int tokenPos) { operand.addressCoding = 346; } -x64Token x64Parser::tokenBranches4250[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4251, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4256}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3966(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4094(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4250(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1007[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1008, x64Parser::tokenBranches1008 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1017, x64Parser::tokenBranches1017 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1026, x64Parser::tokenBranches1026 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1000(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches3965[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3966, x64Parser::tokenBranches3966}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4094, x64Parser::tokenBranches4094}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4250, x64Parser::tokenBranches4250}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3191(x64Operand& operand, int tokenPos) { operand.addressCoding = 247; } -x64Token x64Parser::tokenBranches3190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3191, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3293}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3965}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3314(x64Operand& operand, int tokenPos) { operand.addressCoding = 254; } -x64Token x64Parser::tokenBranches3313[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3314, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3406(x64Operand& operand, int tokenPos) { operand.addressCoding = 270; } -x64Token x64Parser::tokenBranches3405[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3406, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3498(x64Operand& operand, int tokenPos) { operand.addressCoding = 284; } -x64Token x64Parser::tokenBranches3497[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3498, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3313(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3405(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3497(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches999[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1000, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1007 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches3312[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3313, x64Parser::tokenBranches3313}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3405, x64Parser::tokenBranches3405}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3497, x64Parser::tokenBranches3497}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3224(x64Operand& operand, int tokenPos) { operand.addressCoding = 254; } -x64Token x64Parser::tokenBranches3223[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3224, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3312}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3300(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches3299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3392(x64Operand& operand, int tokenPos) { operand.addressCoding = 268; } -x64Token x64Parser::tokenBranches3391[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3392, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3484(x64Operand& operand, int tokenPos) { operand.addressCoding = 282; } -x64Token x64Parser::tokenBranches3483[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3484, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4623(x64Operand& operand, int tokenPos) { operand.addressCoding = 385; } -x64Token x64Parser::tokenBranches4622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4623, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4999(x64Operand& operand, int tokenPos) { operand.addressCoding = 409; } -x64Token x64Parser::tokenBranches4998[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4999, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5211(x64Operand& operand, int tokenPos) { operand.addressCoding = 433; } -x64Token x64Parser::tokenBranches5210[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5211, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4622(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4998(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5210(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1146(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches4621[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4622, x64Parser::tokenBranches4622}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4998, x64Parser::tokenBranches4998}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5210, x64Parser::tokenBranches5210}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4797(x64Operand& operand, int tokenPos) { operand.addressCoding = 385; } -x64Token x64Parser::tokenBranches4620[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4621}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4797, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4620(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1145[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1155(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches4619[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4620, x64Parser::tokenBranches4620}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4630(x64Operand& operand, int tokenPos) { operand.addressCoding = 386; } -x64Token x64Parser::tokenBranches4629[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4630, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5006(x64Operand& operand, int tokenPos) { operand.addressCoding = 410; } -x64Token x64Parser::tokenBranches5005[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5006, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5218(x64Operand& operand, int tokenPos) { operand.addressCoding = 434; } -x64Token x64Parser::tokenBranches5217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4629(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5005(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5217(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1154[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1155, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1136(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4628[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4629, x64Parser::tokenBranches4629}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5005, x64Parser::tokenBranches5005}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5217, x64Parser::tokenBranches5217}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4802(x64Operand& operand, int tokenPos) { operand.addressCoding = 386; } -x64Token x64Parser::tokenBranches4618[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4619}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4628}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4802, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3299(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3391(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3483(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4618(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc1145(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3222[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3223}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3299, x64Parser::tokenBranches3299}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3391, x64Parser::tokenBranches3391}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3483, x64Parser::tokenBranches3483}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4618, x64Parser::tokenBranches4618}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4286(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches4285[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4286, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4293(x64Operand& operand, int tokenPos) { operand.addressCoding = 268; } -x64Token x64Parser::tokenBranches4292[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4293, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4300(x64Operand& operand, int tokenPos) { operand.addressCoding = 282; } -x64Token x64Parser::tokenBranches4299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4285(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4292(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4299(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1154(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4284[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4285, x64Parser::tokenBranches4285}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4292, x64Parser::tokenBranches4292}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4299, x64Parser::tokenBranches4299}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4279(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches4278[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4279, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4284}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4346(x64Operand& operand, int tokenPos) { operand.addressCoding = 353; } -x64Token x64Parser::tokenBranches4345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4353(x64Operand& operand, int tokenPos) { operand.addressCoding = 354; } -x64Token x64Parser::tokenBranches4352[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4353, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4360(x64Operand& operand, int tokenPos) { operand.addressCoding = 355; } -x64Token x64Parser::tokenBranches4359[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4360, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4345(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4352(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4359(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1135[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1136, x64Parser::tokenBranches1136 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1145, x64Parser::tokenBranches1145 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1154, x64Parser::tokenBranches1154 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1128(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches4344[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4345, x64Parser::tokenBranches4345}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4352, x64Parser::tokenBranches4352}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4359, x64Parser::tokenBranches4359}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4339(x64Operand& operand, int tokenPos) { operand.addressCoding = 353; } -x64Token x64Parser::tokenBranches4338[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4339, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4344}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4406(x64Operand& operand, int tokenPos) { operand.addressCoding = 360; } -x64Token x64Parser::tokenBranches4405[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4406, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4422(x64Operand& operand, int tokenPos) { operand.addressCoding = 362; } -x64Token x64Parser::tokenBranches4421[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4422, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4421(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1127[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1128, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1135 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1505(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches4420[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4421, x64Parser::tokenBranches4421}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4413(x64Operand& operand, int tokenPos) { operand.addressCoding = 361; } -x64Token x64Parser::tokenBranches4412[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4413, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4420}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4405(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1504[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1505, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1514(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches4404[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4412}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4405, x64Parser::tokenBranches4405}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4399(x64Operand& operand, int tokenPos) { operand.addressCoding = 359; } -x64Token x64Parser::tokenBranches4398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4399, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4404}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4278(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4338(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4398(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1513[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1514, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1504(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4277[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4278, x64Parser::tokenBranches4278}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4338, x64Parser::tokenBranches4338}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4398, x64Parser::tokenBranches4398}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3214(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches3213[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3214, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3222}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3248(x64Operand& operand, int tokenPos) { operand.addressCoding = 258; } -x64Token x64Parser::tokenBranches3247[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3248, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3247(x64Operand& operand, int tokenPos) -{ - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1513(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3246[] = { - {x64Token::NUMBER, 15, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3247, x64Parser::tokenBranches3247}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3245[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3246}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3251(x64Operand& operand, int tokenPos) { operand.addressCoding = 259; } -x64Token x64Parser::tokenBranches3250[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3251, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc16(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc73(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc480(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc559(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3213(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc3250(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1503[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1504, x64Parser::tokenBranches1504 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1513, x64Parser::tokenBranches1513 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1496(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1495[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1496, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1503 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc999(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1127(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1495(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2[] = { - {x64Token::REGISTER, 96, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches6}, - {x64Token::REGISTER, 95, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches11}, - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches21}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches26}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches471}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches474}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches477}, - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3181}, - {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3184}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3187}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3190}, - {x64Token::REGISTER, 68, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3245}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc3, x64Parser::tokenBranches3}, - {x64Token::REGISTERCLASS, 19, 0, 0, x64Parser::RegClassData1, &x64Parser::TokenFunc16, x64Parser::tokenBranches16}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc73, x64Parser::tokenBranches73}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc480, x64Parser::tokenBranches480}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc559, x64Parser::tokenBranches559}, - {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3213, x64Parser::tokenBranches3213}, - {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3250, x64Parser::tokenBranches3250}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5259(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 439; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5260(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5261(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 441; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5262(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5263(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5264(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5265(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 442; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5266(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches1[] = {{x64Token::TOKEN, 1, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches2}, - { - x64Token::REGISTERCLASS, - 20, - 1, - 0, - x64Parser::RegClassData6, - &x64Parser::TokenFunc5259, - }, - { - x64Token::REGISTERCLASS, - 1, - 1, - 0, - x64Parser::RegClassData7, - &x64Parser::TokenFunc5260, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - x64Parser::RegClassData8, - &x64Parser::TokenFunc5261, - }, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - x64Parser::RegClassData9, - &x64Parser::TokenFunc5262, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - x64Parser::RegClassData10, - &x64Parser::TokenFunc5263, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - x64Parser::RegClassData11, - &x64Parser::TokenFunc5264, - }, - { - x64Token::REGISTERCLASS, - 18, - 1, - 0, - x64Parser::RegClassData12, - &x64Parser::TokenFunc5265, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - x64Parser::RegClassData13, - &x64Parser::TokenFunc5266, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5268(x64Operand& operand, int tokenPos) { operand.operandCoding = 443; } -x64Token x64Parser::tokenBranches5267[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5268, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5270(x64Operand& operand, int tokenPos) { operand.operandCoding = 444; } -x64Token x64Parser::tokenBranches5269[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5270, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5275_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches998[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc999, x64Parser::tokenBranches999 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1127, x64Parser::tokenBranches1127 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1495, x64Parser::tokenBranches1495 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5275(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc521(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5275_16; - operand.values[17] = tokenCoding5275_17; - operand.values[18] = tokenCoding5275_18; - operand.values[19] = tokenCoding5275_19; + operand.addressCoding = 50; } -Coding x64Parser::tokenCoding5287_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc521, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches597 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches998 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 60; +} +x64Token x64Parser::tokenBranches668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc669, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc793(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 79; +} +x64Token x64Parser::tokenBranches792[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc793, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5287(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5287_16; - operand.values[17] = tokenCoding5287_17; - operand.values[18] = tokenCoding5287_18; - operand.values[19] = tokenCoding5287_19; -} -x64Token x64Parser::tokenBranches5274[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5275, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5287, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5273[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5272[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5273}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5279_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc917(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 93; +} +x64Token x64Parser::tokenBranches916[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc668(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc792(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc916(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches667[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc668, x64Parser::tokenBranches668 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc792, x64Parser::tokenBranches792 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc916, x64Parser::tokenBranches916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc545(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 60; +} +x64Token x64Parser::tokenBranches544[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc545, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches667 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc660(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 59; +} +x64Token x64Parser::tokenBranches659[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc660, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5279(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc784(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5279_16; - operand.values[17] = tokenCoding5279_17; - operand.values[18] = tokenCoding5279_18; - operand.values[19] = tokenCoding5279_19; + operand.addressCoding = 78; } -Coding x64Parser::tokenCoding5291_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches783[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc908(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 92; +} +x64Token x64Parser::tokenBranches907[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc908, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2320(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 189; +} +x64Token x64Parser::tokenBranches2319[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2320, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5291(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5291_16; - operand.values[17] = tokenCoding5291_17; - operand.values[18] = tokenCoding5291_18; - operand.values[19] = tokenCoding5291_19; -} -x64Token x64Parser::tokenBranches5278[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5279, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5291, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5277[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5276[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5277}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5283_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2852(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 215; +} +x64Token x64Parser::tokenBranches2851[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2852, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc3150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 240; +} +x64Token x64Parser::tokenBranches3149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3150, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2319(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2851(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3149(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2318[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2319, x64Parser::tokenBranches2319 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2851, x64Parser::tokenBranches2851 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3149, x64Parser::tokenBranches3149 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2560(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 189; +} +x64Token x64Parser::tokenBranches2317[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2318 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2560, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5283(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc2317(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5283_16; - operand.values[17] = tokenCoding5283_17; - operand.values[18] = tokenCoding5283_18; - operand.values[19] = tokenCoding5283_19; + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5295_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches2316[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2317, x64Parser::tokenBranches2317 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2329(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 190; +} +x64Token x64Parser::tokenBranches2328[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2329, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2861(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 216; +} +x64Token x64Parser::tokenBranches2860[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2861, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5295(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5295_16; - operand.values[17] = tokenCoding5295_17; - operand.values[18] = tokenCoding5295_18; - operand.values[19] = tokenCoding5295_19; -} -x64Token x64Parser::tokenBranches5282[] = {{ - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5283, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5295, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5281[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5282}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5280[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5281}, {x64Token::EOT}}; -void x64Parser::TokenFunc5272(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5276(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5280(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc3159(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 241; } -x64Token x64Parser::tokenBranches5271[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5272, x64Parser::tokenBranches5272}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5276, x64Parser::tokenBranches5276}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5280, x64Parser::tokenBranches5280}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5300_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches3158[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3159, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2328(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2860(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3158(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2327[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2328, x64Parser::tokenBranches2328 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2860, x64Parser::tokenBranches2860 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3158, x64Parser::tokenBranches3158 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2567(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 190; +} +x64Token x64Parser::tokenBranches2315[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2316 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2327 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2567, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc659(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc783(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc907(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2315(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches543[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches544 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc659, x64Parser::tokenBranches659 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc783, x64Parser::tokenBranches783 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc907, x64Parser::tokenBranches907 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2315, x64Parser::tokenBranches2315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1659(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 141; +} +x64Token x64Parser::tokenBranches1658[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1659, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1668(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 142; +} +x64Token x64Parser::tokenBranches1667[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1668, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1677(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 143; +} +x64Token x64Parser::tokenBranches1676[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1677, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1658(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1667(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1676(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1657[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1658, x64Parser::tokenBranches1658 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1667, x64Parser::tokenBranches1667 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1676, x64Parser::tokenBranches1676 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 141; +} +x64Token x64Parser::tokenBranches1649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1650, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1657 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1787(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 150; +} +x64Token x64Parser::tokenBranches1786[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1787, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1796(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 151; +} +x64Token x64Parser::tokenBranches1795[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1796, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1805(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 152; +} +x64Token x64Parser::tokenBranches1804[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1805, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1786(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1795(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1804(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1785[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1786, x64Parser::tokenBranches1786 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1795, x64Parser::tokenBranches1795 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1804, x64Parser::tokenBranches1804 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 150; +} +x64Token x64Parser::tokenBranches1777[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1778, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1785 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1955(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 161; +} +x64Token x64Parser::tokenBranches1954[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1955, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1964(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 162; +} +x64Token x64Parser::tokenBranches1963[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1964, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1984(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 163; +} +x64Token x64Parser::tokenBranches1983[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1984, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1995(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 164; +} +x64Token x64Parser::tokenBranches1994[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1995, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1983(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1994(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1982[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1983, x64Parser::tokenBranches1983 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1994, x64Parser::tokenBranches1994 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1973(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 163; +} +x64Token x64Parser::tokenBranches1972[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1973, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1982 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1954(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1963(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1953[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1972 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1954, x64Parser::tokenBranches1954 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1963, x64Parser::tokenBranches1963 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1946(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 160; +} +x64Token x64Parser::tokenBranches1945[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1946, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1953 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1649(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1777(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1945(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1648[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1649, x64Parser::tokenBranches1649 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1777, x64Parser::tokenBranches1777 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1945, x64Parser::tokenBranches1945 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc531(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 59; +} +x64Token x64Parser::tokenBranches530[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc531, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches543 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1648 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc570(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 65; +} +x64Token x64Parser::tokenBranches569[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc570, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1265, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1274(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 115; +} +x64Token x64Parser::tokenBranches1273[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1274, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 116; +} +x64Token x64Parser::tokenBranches1282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1264(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1273(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1282(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1263[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1264, x64Parser::tokenBranches1264 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1273, x64Parser::tokenBranches1273 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1282, x64Parser::tokenBranches1282 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1256(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1255[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1256, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1263 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1393(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1392[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1393, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1402(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 124; +} +x64Token x64Parser::tokenBranches1401[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1402, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1411(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 125; +} +x64Token x64Parser::tokenBranches1410[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1411, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1392(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1401(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1410(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1391[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1392, x64Parser::tokenBranches1392 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1401, x64Parser::tokenBranches1401 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1410, x64Parser::tokenBranches1410 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1384(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1383[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1384, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1391 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1255(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1383(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1254[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1255, x64Parser::tokenBranches1255 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1383, x64Parser::tokenBranches1383 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches1253[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1254 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3782(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3781[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3782, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3791(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 307; +} +x64Token x64Parser::tokenBranches3790[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3791, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3800(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 308; +} +x64Token x64Parser::tokenBranches3799[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3800, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3781(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3790(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3799(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3780[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3781, x64Parser::tokenBranches3781 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3790, x64Parser::tokenBranches3790 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3799, x64Parser::tokenBranches3799 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3773(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3772[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3773, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3780 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3910(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3909[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3910, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3919(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 316; +} +x64Token x64Parser::tokenBranches3918[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3919, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3928(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 317; +} +x64Token x64Parser::tokenBranches3927[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3928, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3909(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3918(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3927(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3908[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3909, x64Parser::tokenBranches3909 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3918, x64Parser::tokenBranches3918 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3927, x64Parser::tokenBranches3927 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3901(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3900[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3901, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3908 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3772(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3900(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3771[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3772, x64Parser::tokenBranches3772 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3900, x64Parser::tokenBranches3900 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3770[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3771 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4038(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches4037[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4038, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4047(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 325; +} +x64Token x64Parser::tokenBranches4046[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4047, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4056(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 326; +} +x64Token x64Parser::tokenBranches4055[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4056, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4037(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4046(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4055(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4036[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4037, x64Parser::tokenBranches4037 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4046, x64Parser::tokenBranches4046 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4055, x64Parser::tokenBranches4055 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4029(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches4028[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4029, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4036 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4166(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4165[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4166, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4175(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 334; +} +x64Token x64Parser::tokenBranches4174[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4175, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4184(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 335; +} +x64Token x64Parser::tokenBranches4183[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4184, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4165(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4174(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4183(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4164[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4165, x64Parser::tokenBranches4165 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4174, x64Parser::tokenBranches4174 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4183, x64Parser::tokenBranches4183 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4157(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4156[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4157, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4164 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4028(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4156(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4027[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4028, x64Parser::tokenBranches4028 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4156, x64Parser::tokenBranches4156 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches4026[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4027 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc13(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc83(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc530(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc569(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches12[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches40 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches47 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches515 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches520 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1253 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3770 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4026 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc13, x64Parser::tokenBranches13 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc83, x64Parser::tokenBranches83 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc530, x64Parser::tokenBranches530 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc569, x64Parser::tokenBranches569 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches11[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches12 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc19(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 3; +} +x64Token x64Parser::tokenBranches18[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc19, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc236(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 23; +} +x64Token x64Parser::tokenBranches235[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc236, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc382(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 38; +} +x64Token x64Parser::tokenBranches381[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc382, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc235(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc381(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches234[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc235, x64Parser::tokenBranches235 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc381, x64Parser::tokenBranches381 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc64(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 8; +} +x64Token x64Parser::tokenBranches63[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc64, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches234 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc151(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 15; +} +x64Token x64Parser::tokenBranches150[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc151, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc297(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 30; +} +x64Token x64Parser::tokenBranches296[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc297, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc443(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 45; +} +x64Token x64Parser::tokenBranches442[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc443, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc63(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc150(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc296(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc442(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches62[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc63, x64Parser::tokenBranches63 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc150, x64Parser::tokenBranches150 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc296, x64Parser::tokenBranches296 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc442, x64Parser::tokenBranches442 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc107(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 15; +} +x64Token x64Parser::tokenBranches61[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches62 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc107, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc245(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 24; +} +x64Token x64Parser::tokenBranches244[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc245, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc391(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 39; +} +x64Token x64Parser::tokenBranches390[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc391, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc244(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc390(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches243[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc244, x64Parser::tokenBranches244 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc390, x64Parser::tokenBranches390 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc71(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 9; +} +x64Token x64Parser::tokenBranches70[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc71, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches243 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc177(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 18; +} +x64Token x64Parser::tokenBranches176[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc177, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc323(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 33; +} +x64Token x64Parser::tokenBranches322[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc323, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc469(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 48; +} +x64Token x64Parser::tokenBranches468[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc469, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc70(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc176(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc322(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc468(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches69[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc70, x64Parser::tokenBranches70 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc176, x64Parser::tokenBranches176 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc322, x64Parser::tokenBranches322 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc468, x64Parser::tokenBranches468 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc125(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 18; +} +x64Token x64Parser::tokenBranches68[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches69 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc125, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc271(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 27; +} +x64Token x64Parser::tokenBranches270[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc271, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc417(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 42; +} +x64Token x64Parser::tokenBranches416[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc417, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc270(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc416(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches269[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc270, x64Parser::tokenBranches270 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc416, x64Parser::tokenBranches416 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc89(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 12; +} +x64Token x64Parser::tokenBranches88[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc89, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches269 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 72; +} +x64Token x64Parser::tokenBranches729[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc854(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 86; +} +x64Token x64Parser::tokenBranches853[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc854, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 180; +} +x64Token x64Parser::tokenBranches2200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2201, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2760(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 206; +} +x64Token x64Parser::tokenBranches2759[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2760, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3058(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 232; +} +x64Token x64Parser::tokenBranches3057[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3058, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2200(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2759(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3057(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2199[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2200, x64Parser::tokenBranches2200 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2759, x64Parser::tokenBranches2759 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3057, x64Parser::tokenBranches3057 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2488(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 180; +} +x64Token x64Parser::tokenBranches2198[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2199 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2488, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2198(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2197[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2198, x64Parser::tokenBranches2198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2210(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 181; +} +x64Token x64Parser::tokenBranches2209[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2210, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2769(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 207; +} +x64Token x64Parser::tokenBranches2768[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2769, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3067(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 233; +} +x64Token x64Parser::tokenBranches3066[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3067, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2209(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2768(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3066(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2208[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2209, x64Parser::tokenBranches2209 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2768, x64Parser::tokenBranches2768 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3066, x64Parser::tokenBranches3066 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2495(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 181; +} +x64Token x64Parser::tokenBranches2196[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2197 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2208 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2495, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc729(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc853(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2196(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches728[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc729, x64Parser::tokenBranches729 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc853, x64Parser::tokenBranches853 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2196, x64Parser::tokenBranches2196 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc491(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 54; +} +x64Token x64Parser::tokenBranches490[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc491, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches728 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc737(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 73; +} +x64Token x64Parser::tokenBranches736[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc737, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc861(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 87; +} +x64Token x64Parser::tokenBranches860[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc861, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2181(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 178; +} +x64Token x64Parser::tokenBranches2180[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2181, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2740(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 204; +} +x64Token x64Parser::tokenBranches2739[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2740, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3038(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 230; +} +x64Token x64Parser::tokenBranches3037[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3038, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2180(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2739(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3037(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2179[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2180, x64Parser::tokenBranches2180 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2739, x64Parser::tokenBranches2739 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3037, x64Parser::tokenBranches3037 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 178; +} +x64Token x64Parser::tokenBranches2178[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2179 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2472, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2178(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2177[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2178, x64Parser::tokenBranches2178 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2190(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 179; +} +x64Token x64Parser::tokenBranches2189[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2190, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2749(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 205; +} +x64Token x64Parser::tokenBranches2748[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2749, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3047(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 231; +} +x64Token x64Parser::tokenBranches3046[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3047, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2189(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2748(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3046(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2188[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2189, x64Parser::tokenBranches2189 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2748, x64Parser::tokenBranches2748 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3046, x64Parser::tokenBranches3046 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2479(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 179; +} +x64Token x64Parser::tokenBranches2176[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2177 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2188 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2479, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2237(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 183; +} +x64Token x64Parser::tokenBranches2236[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2237, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2649(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 199; +} +x64Token x64Parser::tokenBranches2648[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2649, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3027(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 229; +} +x64Token x64Parser::tokenBranches3026[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3027, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2236(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2648(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3026(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2235[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2236, x64Parser::tokenBranches2236 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2648, x64Parser::tokenBranches2648 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3026, x64Parser::tokenBranches3026 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2463(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 183; +} +x64Token x64Parser::tokenBranches2234[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2235 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2463, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc736(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc860(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2176(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches735[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2234 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc736, x64Parser::tokenBranches736 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc860, x64Parser::tokenBranches860 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2176, x64Parser::tokenBranches2176 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1043(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 102; +} +x64Token x64Parser::tokenBranches1042[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1043, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1052(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 103; +} +x64Token x64Parser::tokenBranches1051[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1052, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1061(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 104; +} +x64Token x64Parser::tokenBranches1060[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1061, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1042(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1051(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1060(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1041[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1042, x64Parser::tokenBranches1042 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1051, x64Parser::tokenBranches1051 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1060, x64Parser::tokenBranches1060 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1034(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 102; +} +x64Token x64Parser::tokenBranches1033[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1034, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1041 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1171(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 111; +} +x64Token x64Parser::tokenBranches1170[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1171, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1180(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 112; +} +x64Token x64Parser::tokenBranches1179[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1180, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1189(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 113; +} +x64Token x64Parser::tokenBranches1188[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1189, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1170(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1179(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1188(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1169[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1170, x64Parser::tokenBranches1170 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1179, x64Parser::tokenBranches1179 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1188, x64Parser::tokenBranches1188 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1162(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 111; +} +x64Token x64Parser::tokenBranches1161[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1162, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1530(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 136; +} +x64Token x64Parser::tokenBranches1529[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1530, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1539(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 137; +} +x64Token x64Parser::tokenBranches1538[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1539, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1529(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1538(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1528[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1529, x64Parser::tokenBranches1529 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1538, x64Parser::tokenBranches1538 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1521(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 136; +} +x64Token x64Parser::tokenBranches1520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1521, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1528 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1033(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1161(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1520(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1032[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1033, x64Parser::tokenBranches1033 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1161, x64Parser::tokenBranches1161 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1520, x64Parser::tokenBranches1520 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc496(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 55; +} +x64Token x64Parser::tokenBranches495[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc496, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches735 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1032 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc637(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 56; +} +x64Token x64Parser::tokenBranches636[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc637, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc761(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 77; +} +x64Token x64Parser::tokenBranches760[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc761, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc885(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 91; +} +x64Token x64Parser::tokenBranches884[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc885, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2280(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 187; +} +x64Token x64Parser::tokenBranches2279[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2280, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2812(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 212; +} +x64Token x64Parser::tokenBranches2811[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2812, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 238; +} +x64Token x64Parser::tokenBranches3109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2279(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2811(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3109(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2278[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2279, x64Parser::tokenBranches2279 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2811, x64Parser::tokenBranches2811 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3109, x64Parser::tokenBranches3109 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2528(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 187; +} +x64Token x64Parser::tokenBranches2277[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2278 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2528, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2277(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2276[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2277, x64Parser::tokenBranches2277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2289(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 188; +} +x64Token x64Parser::tokenBranches2288[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2289, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2821(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 213; +} +x64Token x64Parser::tokenBranches2820[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2821, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3119(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 239; +} +x64Token x64Parser::tokenBranches3118[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3119, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2288(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2820(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3118(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2287[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2288, x64Parser::tokenBranches2288 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2820, x64Parser::tokenBranches2820 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3118, x64Parser::tokenBranches3118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2535(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 188; +} +x64Token x64Parser::tokenBranches2275[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2276 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2287 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2535, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc636(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc760(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc884(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2275(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches635[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc636, x64Parser::tokenBranches636 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc760, x64Parser::tokenBranches760 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc884, x64Parser::tokenBranches884 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2275, x64Parser::tokenBranches2275 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1299(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 120; +} +x64Token x64Parser::tokenBranches1298[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1299, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1308(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 121; +} +x64Token x64Parser::tokenBranches1307[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1308, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1317(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 122; +} +x64Token x64Parser::tokenBranches1316[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1317, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1298(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1307(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1316(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1297[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1298, x64Parser::tokenBranches1298 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1307, x64Parser::tokenBranches1307 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1316, x64Parser::tokenBranches1316 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 120; +} +x64Token x64Parser::tokenBranches1289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1290, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1427(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 129; +} +x64Token x64Parser::tokenBranches1426[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1427, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1436(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 130; +} +x64Token x64Parser::tokenBranches1435[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1436, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1445(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 131; +} +x64Token x64Parser::tokenBranches1444[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1445, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1426(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1435(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1444(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1425[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1426, x64Parser::tokenBranches1426 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1435, x64Parser::tokenBranches1435 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1444, x64Parser::tokenBranches1444 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1418(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 129; +} +x64Token x64Parser::tokenBranches1417[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1418, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1425 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1574(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 139; +} +x64Token x64Parser::tokenBranches1573[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1574, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1583(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 140; +} +x64Token x64Parser::tokenBranches1582[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1583, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1573(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1582(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1572[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1573, x64Parser::tokenBranches1573 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1582, x64Parser::tokenBranches1582 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1565(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 139; +} +x64Token x64Parser::tokenBranches1564[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1565, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1572 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1289(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1417(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1564(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1288[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1289, x64Parser::tokenBranches1289 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1417, x64Parser::tokenBranches1417 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1564, x64Parser::tokenBranches1564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc501(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 56; +} +x64Token x64Parser::tokenBranches500[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc501, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches635 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1288 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc685(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 62; +} +x64Token x64Parser::tokenBranches684[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc685, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc809(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 81; +} +x64Token x64Parser::tokenBranches808[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc809, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc926(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 94; +} +x64Token x64Parser::tokenBranches925[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc926, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc684(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc808(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc925(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches683[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc684, x64Parser::tokenBranches684 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc808, x64Parser::tokenBranches808 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc925, x64Parser::tokenBranches925 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc557(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 62; +} +x64Token x64Parser::tokenBranches556[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc557, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches683 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc676(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 61; +} +x64Token x64Parser::tokenBranches675[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc676, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc800(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 80; +} +x64Token x64Parser::tokenBranches799[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc800, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc933(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 95; +} +x64Token x64Parser::tokenBranches932[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc933, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2340(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 191; +} +x64Token x64Parser::tokenBranches2339[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2340, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2872(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 217; +} +x64Token x64Parser::tokenBranches2871[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2872, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 242; +} +x64Token x64Parser::tokenBranches3169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2339(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2871(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3169(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2338[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2339, x64Parser::tokenBranches2339 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2871, x64Parser::tokenBranches2871 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3169, x64Parser::tokenBranches3169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2576(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 191; +} +x64Token x64Parser::tokenBranches2337[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2338 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2576, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2337(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2336[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2337, x64Parser::tokenBranches2337 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2349(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 192; +} +x64Token x64Parser::tokenBranches2348[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2349, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2881(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 218; +} +x64Token x64Parser::tokenBranches2880[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2881, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3179(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 243; +} +x64Token x64Parser::tokenBranches3178[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3179, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2348(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2880(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3178(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2347[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2348, x64Parser::tokenBranches2348 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2880, x64Parser::tokenBranches2880 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3178, x64Parser::tokenBranches3178 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2583(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 192; +} +x64Token x64Parser::tokenBranches2335[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2336 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2347 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2583, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc675(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc799(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc932(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2335(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches555[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches556 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc675, x64Parser::tokenBranches675 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc799, x64Parser::tokenBranches799 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc932, x64Parser::tokenBranches932 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2335, x64Parser::tokenBranches2335 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1693(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 144; +} +x64Token x64Parser::tokenBranches1692[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1693, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1702(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 145; +} +x64Token x64Parser::tokenBranches1701[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1702, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1711(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 146; +} +x64Token x64Parser::tokenBranches1710[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1711, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1692(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1701(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1710(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1691[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1692, x64Parser::tokenBranches1692 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1701, x64Parser::tokenBranches1701 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1710, x64Parser::tokenBranches1710 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1684(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 144; +} +x64Token x64Parser::tokenBranches1683[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1684, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1691 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1821(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 153; +} +x64Token x64Parser::tokenBranches1820[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1821, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1830(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 154; +} +x64Token x64Parser::tokenBranches1829[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1830, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1839(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 155; +} +x64Token x64Parser::tokenBranches1838[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1839, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1820(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1829(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1838(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1819[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1820, x64Parser::tokenBranches1820 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1829, x64Parser::tokenBranches1829 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1838, x64Parser::tokenBranches1838 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1812(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 153; +} +x64Token x64Parser::tokenBranches1811[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1812, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1819 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2011(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 165; +} +x64Token x64Parser::tokenBranches2010[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2011, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2020(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 166; +} +x64Token x64Parser::tokenBranches2019[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2020, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2040(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 167; +} +x64Token x64Parser::tokenBranches2039[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2040, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2051(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 168; +} +x64Token x64Parser::tokenBranches2050[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2051, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2039(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2050(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2038[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2039, x64Parser::tokenBranches2039 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2050, x64Parser::tokenBranches2050 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2029(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 167; +} +x64Token x64Parser::tokenBranches2028[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2029, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2038 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2010(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2019(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2009[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2028 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2010, x64Parser::tokenBranches2010 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2019, x64Parser::tokenBranches2019 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2002(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 165; +} +x64Token x64Parser::tokenBranches2001[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2002, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2009 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1683(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1811(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2001(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1682[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1683, x64Parser::tokenBranches1683 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1811, x64Parser::tokenBranches1811 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2001, x64Parser::tokenBranches2001 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc550(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 61; +} +x64Token x64Parser::tokenBranches549[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc550, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches555 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1682 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc575(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 66; +} +x64Token x64Parser::tokenBranches574[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc575, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3277(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 248; +} +x64Token x64Parser::tokenBranches3276[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3277, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3368(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 264; +} +x64Token x64Parser::tokenBranches3367[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3368, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3460(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 278; +} +x64Token x64Parser::tokenBranches3459[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3460, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4569(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 379; +} +x64Token x64Parser::tokenBranches4568[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4569, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4945(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 403; +} +x64Token x64Parser::tokenBranches4944[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4945, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5157(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 427; +} +x64Token x64Parser::tokenBranches5156[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5157, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4568(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4944(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5156(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4567[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4568, x64Parser::tokenBranches4568 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4944, x64Parser::tokenBranches4944 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5156, x64Parser::tokenBranches5156 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4755(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 379; +} +x64Token x64Parser::tokenBranches4566[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4567 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4755, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4566(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4565[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4566, x64Parser::tokenBranches4566 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4578(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 380; +} +x64Token x64Parser::tokenBranches4577[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4578, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4954(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 404; +} +x64Token x64Parser::tokenBranches4953[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4954, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5166(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 428; +} +x64Token x64Parser::tokenBranches5165[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5166, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4577(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4953(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5165(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4576[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4577, x64Parser::tokenBranches4577 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4953, x64Parser::tokenBranches4953 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5165, x64Parser::tokenBranches5165 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4762(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 380; +} +x64Token x64Parser::tokenBranches4564[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4565 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4576 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4762, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3276(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3367(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3459(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4564(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3275[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3276, x64Parser::tokenBranches3276 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3367, x64Parser::tokenBranches3367 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3459, x64Parser::tokenBranches3459 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4564, x64Parser::tokenBranches4564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3196(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 248; +} +x64Token x64Parser::tokenBranches3195[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3196, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3275 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3337(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 256; +} +x64Token x64Parser::tokenBranches3336[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3337, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 273; +} +x64Token x64Parser::tokenBranches3428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3521(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 287; +} +x64Token x64Parser::tokenBranches3520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3521, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3336(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3428(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3520(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3335[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3336, x64Parser::tokenBranches3336 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3428, x64Parser::tokenBranches3428 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3520, x64Parser::tokenBranches3520 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3236(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 256; +} +x64Token x64Parser::tokenBranches3235[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3236, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3335 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3375(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 265; +} +x64Token x64Parser::tokenBranches3374[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3375, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3467(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 279; +} +x64Token x64Parser::tokenBranches3466[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3467, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4589(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 381; +} +x64Token x64Parser::tokenBranches4588[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4589, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4965(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 405; +} +x64Token x64Parser::tokenBranches4964[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4965, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5177(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 429; +} +x64Token x64Parser::tokenBranches5176[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5177, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4588(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4964(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5176(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4587[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4588, x64Parser::tokenBranches4588 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4964, x64Parser::tokenBranches4964 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5176, x64Parser::tokenBranches5176 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4771(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 381; +} +x64Token x64Parser::tokenBranches4586[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4587 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4771, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4586(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4585[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4586, x64Parser::tokenBranches4586 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4598(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 382; +} +x64Token x64Parser::tokenBranches4597[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4598, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4974(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 406; +} +x64Token x64Parser::tokenBranches4973[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4974, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5186(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 430; +} +x64Token x64Parser::tokenBranches5185[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5186, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4597(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4973(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5185(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4596[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4597, x64Parser::tokenBranches4597 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4973, x64Parser::tokenBranches4973 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5185, x64Parser::tokenBranches5185 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 382; +} +x64Token x64Parser::tokenBranches4584[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4585 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4596 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3374(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3466(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4584(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3234[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3235 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3374, x64Parser::tokenBranches3374 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3466, x64Parser::tokenBranches3466 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4584, x64Parser::tokenBranches4584 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 249; +} +x64Token x64Parser::tokenBranches3282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3572(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 289; +} +x64Token x64Parser::tokenBranches3571[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3572, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3581(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 290; +} +x64Token x64Parser::tokenBranches3580[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3581, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3590(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 291; +} +x64Token x64Parser::tokenBranches3589[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3590, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3571(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3580(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3589(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3570[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3571, x64Parser::tokenBranches3571 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3580, x64Parser::tokenBranches3580 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3589, x64Parser::tokenBranches3589 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3563(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 289; +} +x64Token x64Parser::tokenBranches3562[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3563, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3570 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3632(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 295; +} +x64Token x64Parser::tokenBranches3631[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3632, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3641(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 296; +} +x64Token x64Parser::tokenBranches3640[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3641, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 297; +} +x64Token x64Parser::tokenBranches3649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3650, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3631(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3640(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3649(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3630[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3631, x64Parser::tokenBranches3631 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3640, x64Parser::tokenBranches3640 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3649, x64Parser::tokenBranches3649 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 295; +} +x64Token x64Parser::tokenBranches3622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3623, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3630 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3678(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 301; +} +x64Token x64Parser::tokenBranches3677[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3678, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3677(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3676[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3677, x64Parser::tokenBranches3677 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 300; +} +x64Token x64Parser::tokenBranches3668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3669, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3676 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3706(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 305; +} +x64Token x64Parser::tokenBranches3705[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3706, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3705(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3704[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3705, x64Parser::tokenBranches3705 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3697(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 304; +} +x64Token x64Parser::tokenBranches3696[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3697, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3704 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3562(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3622(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3668(x64Operand &operand, int tokenPos) +{ + operand.values[13] = new Coding[2]; + CleanupValues.push_back(operand.values[13]); + operand.values[13]->type = Coding::number; + operand.values[13]->val = operands.size(); + operand.values[13]->bits = 0; + operand.values[13]->field = 0; + operand.values[13]->unary = 0; + operand.values[13]->binary = 0; + operand.values[13][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3696(x64Operand &operand, int tokenPos) +{ + operand.values[14] = new Coding[2]; + CleanupValues.push_back(operand.values[14]); + operand.values[14]->type = Coding::number; + operand.values[14]->val = operands.size(); + operand.values[14]->bits = 0; + operand.values[14]->field = 0; + operand.values[14]->unary = 0; + operand.values[14]->binary = 0; + operand.values[14][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3561[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3562, x64Parser::tokenBranches3562 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3622, x64Parser::tokenBranches3622 }, + {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3668, x64Parser::tokenBranches3668 }, + {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3696, x64Parser::tokenBranches3696 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 249; +} +void x64Parser::TokenFunc3282(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3201, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3234 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3282, x64Parser::tokenBranches3282 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3561 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 250; +} +x64Token x64Parser::tokenBranches3289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3290, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3382(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 266; +} +x64Token x64Parser::tokenBranches3381[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3382, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3474(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 280; +} +x64Token x64Parser::tokenBranches3473[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3474, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4481(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 369; +} +x64Token x64Parser::tokenBranches4480[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4481, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4857(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 393; +} +x64Token x64Parser::tokenBranches4856[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4857, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5069(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 417; +} +x64Token x64Parser::tokenBranches5068[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5069, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4480(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4856(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5068(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4479[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4480, x64Parser::tokenBranches4480 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4856, x64Parser::tokenBranches4856 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5068, x64Parser::tokenBranches5068 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4687(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 369; +} +x64Token x64Parser::tokenBranches4478[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4479 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4687, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4549(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 377; +} +x64Token x64Parser::tokenBranches4548[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4549, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4925(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 401; +} +x64Token x64Parser::tokenBranches4924[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4925, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 425; +} +x64Token x64Parser::tokenBranches5136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4548(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4924(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5136(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4547[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4548, x64Parser::tokenBranches4548 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4924, x64Parser::tokenBranches4924 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5136, x64Parser::tokenBranches5136 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4739(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 377; +} +x64Token x64Parser::tokenBranches4546[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4547 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4739, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4546(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4545[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4546, x64Parser::tokenBranches4546 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4558(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 378; +} +x64Token x64Parser::tokenBranches4557[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4558, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4934(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 402; +} +x64Token x64Parser::tokenBranches4933[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4934, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5146(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 426; +} +x64Token x64Parser::tokenBranches5145[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4557(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4933(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5145(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4556[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4557, x64Parser::tokenBranches4557 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4933, x64Parser::tokenBranches4933 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5145, x64Parser::tokenBranches5145 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4746(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 378; +} +x64Token x64Parser::tokenBranches4544[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4545 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4556 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4746, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3289(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3381(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3473(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4544(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3288[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4478 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3289, x64Parser::tokenBranches3289 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3381, x64Parser::tokenBranches3381 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3473, x64Parser::tokenBranches3473 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4544, x64Parser::tokenBranches4544 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3816(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 312; +} +x64Token x64Parser::tokenBranches3815[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3816, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3825(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 313; +} +x64Token x64Parser::tokenBranches3824[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3825, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3834(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 314; +} +x64Token x64Parser::tokenBranches3833[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3834, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3815(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3824(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3833(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3814[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3815, x64Parser::tokenBranches3815 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3824, x64Parser::tokenBranches3824 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3833, x64Parser::tokenBranches3833 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3807(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 312; +} +x64Token x64Parser::tokenBranches3806[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3807, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3814 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3944(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 321; +} +x64Token x64Parser::tokenBranches3943[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3944, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3953(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 322; +} +x64Token x64Parser::tokenBranches3952[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3953, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3962(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 323; +} +x64Token x64Parser::tokenBranches3961[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3962, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3943(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3952(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3961(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3942[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3943, x64Parser::tokenBranches3943 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3952, x64Parser::tokenBranches3952 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3961, x64Parser::tokenBranches3961 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3935(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 321; +} +x64Token x64Parser::tokenBranches3934[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3935, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3942 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4246(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 345; +} +x64Token x64Parser::tokenBranches4245[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4245(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4244[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4245, x64Parser::tokenBranches4245 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4237(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 344; +} +x64Token x64Parser::tokenBranches4236[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4237, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4244 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3806(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3934(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4236(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3805[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3806, x64Parser::tokenBranches3806 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3934, x64Parser::tokenBranches3934 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4236, x64Parser::tokenBranches4236 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3206(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 250; +} +x64Token x64Parser::tokenBranches3205[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3206, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3288 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3805 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3321(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 251; +} +x64Token x64Parser::tokenBranches3320[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3321, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3413(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 271; +} +x64Token x64Parser::tokenBranches3412[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3413, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3505(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 285; +} +x64Token x64Parser::tokenBranches3504[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3505, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4490(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 370; +} +x64Token x64Parser::tokenBranches4489[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4490, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4866(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 394; +} +x64Token x64Parser::tokenBranches4865[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4866, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5078(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 418; +} +x64Token x64Parser::tokenBranches5077[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5078, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4489(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4865(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5077(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4488[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4489, x64Parser::tokenBranches4489 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4865, x64Parser::tokenBranches4865 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5077, x64Parser::tokenBranches5077 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4694(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 370; +} +x64Token x64Parser::tokenBranches4487[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4488 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4694, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4641(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 387; +} +x64Token x64Parser::tokenBranches4640[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4641, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5017(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 411; +} +x64Token x64Parser::tokenBranches5016[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5017, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5229(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 435; +} +x64Token x64Parser::tokenBranches5228[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5229, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4640(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5016(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5228(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4639[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4640, x64Parser::tokenBranches4640 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5016, x64Parser::tokenBranches5016 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5228, x64Parser::tokenBranches5228 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4811(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 387; +} +x64Token x64Parser::tokenBranches4638[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4639 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4811, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4638(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4637[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4638, x64Parser::tokenBranches4638 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 388; +} +x64Token x64Parser::tokenBranches4649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4650, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5026(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 412; +} +x64Token x64Parser::tokenBranches5025[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5026, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5238(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 436; +} +x64Token x64Parser::tokenBranches5237[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5238, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4649(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5025(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5237(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4648[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4649, x64Parser::tokenBranches4649 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5025, x64Parser::tokenBranches5025 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5237, x64Parser::tokenBranches5237 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4818(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 388; +} +x64Token x64Parser::tokenBranches4636[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4637 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4648 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4818, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3320(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3412(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3504(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4636(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3319[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4487 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3320, x64Parser::tokenBranches3320 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3412, x64Parser::tokenBranches3412 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3504, x64Parser::tokenBranches3504 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4636, x64Parser::tokenBranches4636 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4072(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 330; +} +x64Token x64Parser::tokenBranches4071[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4072, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4081(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 331; +} +x64Token x64Parser::tokenBranches4080[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4081, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4090(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 332; +} +x64Token x64Parser::tokenBranches4089[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4090, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4071(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4080(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4089(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4070[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4071, x64Parser::tokenBranches4071 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4080, x64Parser::tokenBranches4080 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4089, x64Parser::tokenBranches4089 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4063(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 330; +} +x64Token x64Parser::tokenBranches4062[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4063, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4070 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4200(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 339; +} +x64Token x64Parser::tokenBranches4199[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4200, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4209(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 340; +} +x64Token x64Parser::tokenBranches4208[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4209, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 341; +} +x64Token x64Parser::tokenBranches4217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4199(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4208(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4217(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4198[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4199, x64Parser::tokenBranches4199 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4208, x64Parser::tokenBranches4208 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4217, x64Parser::tokenBranches4217 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 339; +} +x64Token x64Parser::tokenBranches4190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4191, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4274(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 349; +} +x64Token x64Parser::tokenBranches4273[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4274, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4273(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4272[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4273, x64Parser::tokenBranches4273 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 348; +} +x64Token x64Parser::tokenBranches4264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4265, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4272 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4062(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4190(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4264(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4061[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4062, x64Parser::tokenBranches4062 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4190, x64Parser::tokenBranches4190 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4264, x64Parser::tokenBranches4264 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3211(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 251; +} +x64Token x64Parser::tokenBranches3210[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3211, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3319 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4061 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 257; +} +x64Token x64Parser::tokenBranches3345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3438(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 274; +} +x64Token x64Parser::tokenBranches3437[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3438, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3530(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 288; +} +x64Token x64Parser::tokenBranches3529[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3530, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3345(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3437(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3529(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3344[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3345, x64Parser::tokenBranches3345 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3437, x64Parser::tokenBranches3437 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3529, x64Parser::tokenBranches3529 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3243(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 257; +} +x64Token x64Parser::tokenBranches3242[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3243, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3344 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3328(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 255; +} +x64Token x64Parser::tokenBranches3327[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3328, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3420(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 272; +} +x64Token x64Parser::tokenBranches3419[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3420, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3512(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 286; +} +x64Token x64Parser::tokenBranches3511[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3512, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4661(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 389; +} +x64Token x64Parser::tokenBranches4660[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4661, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5037(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 413; +} +x64Token x64Parser::tokenBranches5036[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5037, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5249(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 437; +} +x64Token x64Parser::tokenBranches5248[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5249, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4660(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5036(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5248(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4659[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4660, x64Parser::tokenBranches4660 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5036, x64Parser::tokenBranches5036 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5248, x64Parser::tokenBranches5248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4827(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 389; +} +x64Token x64Parser::tokenBranches4658[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4659 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4827, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4658(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4657[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4658, x64Parser::tokenBranches4658 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4670(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 390; +} +x64Token x64Parser::tokenBranches4669[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4670, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5046(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 414; +} +x64Token x64Parser::tokenBranches5045[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5046, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5258(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 438; +} +x64Token x64Parser::tokenBranches5257[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5258, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4669(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5045(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5257(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4668[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4669, x64Parser::tokenBranches4669 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5045, x64Parser::tokenBranches5045 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5257, x64Parser::tokenBranches5257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4834(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 390; +} +x64Token x64Parser::tokenBranches4656[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4657 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4668 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4834, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3327(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3419(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3511(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4656(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3241[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3242 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3327, x64Parser::tokenBranches3327 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3419, x64Parser::tokenBranches3419 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3511, x64Parser::tokenBranches3511 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4656, x64Parser::tokenBranches4656 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4316(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 350; +} +x64Token x64Parser::tokenBranches4315[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4316, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4325(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 351; +} +x64Token x64Parser::tokenBranches4324[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4325, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4334(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 352; +} +x64Token x64Parser::tokenBranches4333[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4334, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4315(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4324(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4333(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4314[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4315, x64Parser::tokenBranches4315 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4324, x64Parser::tokenBranches4324 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4333, x64Parser::tokenBranches4333 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4307(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 350; +} +x64Token x64Parser::tokenBranches4306[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4307, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4314 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4376(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 356; +} +x64Token x64Parser::tokenBranches4375[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4376, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4385(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 357; +} +x64Token x64Parser::tokenBranches4384[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4385, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4394(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 358; +} +x64Token x64Parser::tokenBranches4393[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4394, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4375(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4384(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4393(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4374[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4375, x64Parser::tokenBranches4375 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4384, x64Parser::tokenBranches4384 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4393, x64Parser::tokenBranches4393 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4367(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 356; +} +x64Token x64Parser::tokenBranches4366[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4367, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4374 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4438(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 364; +} +x64Token x64Parser::tokenBranches4437[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4438, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4458(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 366; +} +x64Token x64Parser::tokenBranches4457[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4458, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4457(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4456[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4457, x64Parser::tokenBranches4457 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4447(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 365; +} +x64Token x64Parser::tokenBranches4446[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4447, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4456 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4437(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4436[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4446 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4437, x64Parser::tokenBranches4437 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 363; +} +x64Token x64Parser::tokenBranches4428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4429, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4436 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4306(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4366(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4428(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4305[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4306, x64Parser::tokenBranches4306 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4366, x64Parser::tokenBranches4366 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4428, x64Parser::tokenBranches4428 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3229(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 255; +} +x64Token x64Parser::tokenBranches3228[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3229, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3241 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3256(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 260; +} +x64Token x64Parser::tokenBranches3255[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3256, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc18(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc88(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc549(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc574(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3228(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc3255(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches17[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches61 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches68 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches490 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches495 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches500 }, + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3195 }, + {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3200 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3205 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3210 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc18, x64Parser::tokenBranches18 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc88, x64Parser::tokenBranches88 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc549, x64Parser::tokenBranches549 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc574, x64Parser::tokenBranches574 }, + {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3228, x64Parser::tokenBranches3228 }, + {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3255, x64Parser::tokenBranches3255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches16[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches17 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc184(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 19; +} +x64Token x64Parser::tokenBranches183[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc184, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc330(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 34; +} +x64Token x64Parser::tokenBranches329[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc330, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc183(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc329(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches182[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc183, x64Parser::tokenBranches183 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc329, x64Parser::tokenBranches329 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc24(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 4; +} +x64Token x64Parser::tokenBranches23[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc24, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches182 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc276(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 28; +} +x64Token x64Parser::tokenBranches275[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc276, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc422(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 43; +} +x64Token x64Parser::tokenBranches421[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc422, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc23(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc129(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc275(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc421(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches22[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc23, x64Parser::tokenBranches23 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc129, x64Parser::tokenBranches129 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc275, x64Parser::tokenBranches275 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc421, x64Parser::tokenBranches421 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc92(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches21[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches22 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc92, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 20; +} +x64Token x64Parser::tokenBranches190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc191, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc337(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 35; +} +x64Token x64Parser::tokenBranches336[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc337, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc190(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc336(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches189[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc190, x64Parser::tokenBranches190 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc336, x64Parser::tokenBranches336 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc29(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 5; +} +x64Token x64Parser::tokenBranches28[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc29, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches189 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc156(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches155[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc156, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc302(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 31; +} +x64Token x64Parser::tokenBranches301[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc302, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc448(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 46; +} +x64Token x64Parser::tokenBranches447[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc448, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc28(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc155(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc301(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc447(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches27[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc28, x64Parser::tokenBranches28 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc155, x64Parser::tokenBranches155 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc301, x64Parser::tokenBranches301 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc447, x64Parser::tokenBranches447 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches26[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches27 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc250(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 25; +} +x64Token x64Parser::tokenBranches249[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc250, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc396(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 40; +} +x64Token x64Parser::tokenBranches395[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc396, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc249(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc395(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches248[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc249, x64Parser::tokenBranches249 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc395, x64Parser::tokenBranches395 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc74(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 10; +} +x64Token x64Parser::tokenBranches73[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc74, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc580(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; +} +x64Token x64Parser::tokenBranches579[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc580, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc690(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 68; +} +x64Token x64Parser::tokenBranches689[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc690, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc814(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 82; +} +x64Token x64Parser::tokenBranches813[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc814, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2083(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; +} +x64Token x64Parser::tokenBranches2082[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2083, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2615(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 196; +} +x64Token x64Parser::tokenBranches2614[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2615, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2913(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 222; +} +x64Token x64Parser::tokenBranches2912[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2913, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2082(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2614(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2912(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2081[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2082, x64Parser::tokenBranches2082 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2614, x64Parser::tokenBranches2614 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2912, x64Parser::tokenBranches2912 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2373(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; +} +x64Token x64Parser::tokenBranches2080[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2081 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2373, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2080(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2079[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2080, x64Parser::tokenBranches2080 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2090(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2089[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2090, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2622(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 197; +} +x64Token x64Parser::tokenBranches2621[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2622, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2920(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 223; +} +x64Token x64Parser::tokenBranches2919[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2920, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2089(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2621(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2919(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2088[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2089, x64Parser::tokenBranches2089 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2621, x64Parser::tokenBranches2621 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2919, x64Parser::tokenBranches2919 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2378(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2078[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2079 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2088 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2378, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc579(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc689(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc813(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2078(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches578[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc579, x64Parser::tokenBranches579 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc689, x64Parser::tokenBranches689 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc813, x64Parser::tokenBranches813 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2078, x64Parser::tokenBranches2078 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; +} +x64Token x64Parser::tokenBranches471[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc472, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches578 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc585(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; +} +x64Token x64Parser::tokenBranches584[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc585, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc695(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 69; +} +x64Token x64Parser::tokenBranches694[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc695, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc819(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 83; +} +x64Token x64Parser::tokenBranches818[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc819, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2058(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2057[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2058, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2590(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 193; +} +x64Token x64Parser::tokenBranches2589[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2590, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2888(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 219; +} +x64Token x64Parser::tokenBranches2887[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2888, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2057(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2589(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2887(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2056[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2057, x64Parser::tokenBranches2057 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2589, x64Parser::tokenBranches2589 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2887, x64Parser::tokenBranches2887 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2354(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2055[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2056 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2354, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2067(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2066[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2067, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2599(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 194; +} +x64Token x64Parser::tokenBranches2598[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2599, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2897(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 220; +} +x64Token x64Parser::tokenBranches2896[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2897, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2066(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2598(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2896(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2065[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2066, x64Parser::tokenBranches2066 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2598, x64Parser::tokenBranches2598 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2896, x64Parser::tokenBranches2896 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2361(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2064[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2065 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2361, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2064(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2063[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2064, x64Parser::tokenBranches2064 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2074(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; +} +x64Token x64Parser::tokenBranches2073[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2074, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2606(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 195; +} +x64Token x64Parser::tokenBranches2605[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2606, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2904(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 221; +} +x64Token x64Parser::tokenBranches2903[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2904, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2073(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2605(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2903(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2072[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2073, x64Parser::tokenBranches2073 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2605, x64Parser::tokenBranches2605 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2903, x64Parser::tokenBranches2903 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2366(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; +} +x64Token x64Parser::tokenBranches2062[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2063 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2072 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2366, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc584(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc694(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc818(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2062(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches583[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2055 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc584, x64Parser::tokenBranches584 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc694, x64Parser::tokenBranches694 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc818, x64Parser::tokenBranches818 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2062, x64Parser::tokenBranches2062 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc945(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches944[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc945, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc952(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 97; +} +x64Token x64Parser::tokenBranches951[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc952, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc959(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 98; +} +x64Token x64Parser::tokenBranches958[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc959, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc944(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc951(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc958(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches943[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc944, x64Parser::tokenBranches944 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc951, x64Parser::tokenBranches951 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc958, x64Parser::tokenBranches958 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc938(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches937[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc938, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches943 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1073(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; +} +x64Token x64Parser::tokenBranches1072[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1073, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1080(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 106; +} +x64Token x64Parser::tokenBranches1079[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1080, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1087(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 107; +} +x64Token x64Parser::tokenBranches1086[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1087, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1072(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1079(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1086(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1071[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1072, x64Parser::tokenBranches1072 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1079, x64Parser::tokenBranches1079 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1086, x64Parser::tokenBranches1086 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1066(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; +} +x64Token x64Parser::tokenBranches1065[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1066, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1071 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1457(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1456[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1457, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1464(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; +} +x64Token x64Parser::tokenBranches1463[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1464, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1456(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1463(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1455[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1456, x64Parser::tokenBranches1456 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1463, x64Parser::tokenBranches1463 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1450(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1449[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1450, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1455 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc937(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1065(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1449(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches936[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc937, x64Parser::tokenBranches937 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1065, x64Parser::tokenBranches1065 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1449, x64Parser::tokenBranches1449 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc475(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; +} +x64Token x64Parser::tokenBranches474[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc475, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches583 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches936 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc618(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 51; +} +x64Token x64Parser::tokenBranches617[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc618, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc742(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 74; +} +x64Token x64Parser::tokenBranches741[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc742, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc866(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 88; +} +x64Token x64Parser::tokenBranches865[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc866, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2246(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2245[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 208; +} +x64Token x64Parser::tokenBranches2777[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3076(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 234; +} +x64Token x64Parser::tokenBranches3075[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3076, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2245(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2777(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3075(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2244[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2245, x64Parser::tokenBranches2245 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2777, x64Parser::tokenBranches2777 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3075, x64Parser::tokenBranches3075 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2502(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2243[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2244 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2502, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2243(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2242[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2243, x64Parser::tokenBranches2243 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2253(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 184; +} +x64Token x64Parser::tokenBranches2252[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2253, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2785(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 209; +} +x64Token x64Parser::tokenBranches2784[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2785, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3083(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 235; +} +x64Token x64Parser::tokenBranches3082[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3083, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2252(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2784(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3082(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2251[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2252, x64Parser::tokenBranches2252 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2784, x64Parser::tokenBranches2784 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3082, x64Parser::tokenBranches3082 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2507(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 184; +} +x64Token x64Parser::tokenBranches2241[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2242 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2251 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2507, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc617(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc741(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc865(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2241(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches616[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc617, x64Parser::tokenBranches617 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc741, x64Parser::tokenBranches741 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc865, x64Parser::tokenBranches865 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2241, x64Parser::tokenBranches2241 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1201, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1208(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 115; +} +x64Token x64Parser::tokenBranches1207[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1208, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1215(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 116; +} +x64Token x64Parser::tokenBranches1214[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1215, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1200(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1207(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1214(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1199[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1200, x64Parser::tokenBranches1200 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1207, x64Parser::tokenBranches1207 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1214, x64Parser::tokenBranches1214 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1194(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1193[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1194, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1199 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1329(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1328[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1329, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1336(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 124; +} +x64Token x64Parser::tokenBranches1335[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1336, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1343(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 125; +} +x64Token x64Parser::tokenBranches1342[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1343, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1328(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1335(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1342(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1327[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1328, x64Parser::tokenBranches1328 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1335, x64Parser::tokenBranches1335 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1342, x64Parser::tokenBranches1342 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1322(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1321[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1322, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1327 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1551(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 138; +} +x64Token x64Parser::tokenBranches1550[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1558(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; +} +x64Token x64Parser::tokenBranches1557[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1558, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1550(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1557(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1549[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1550, x64Parser::tokenBranches1550 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1557, x64Parser::tokenBranches1557 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1544(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 138; +} +x64Token x64Parser::tokenBranches1543[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1544, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1549 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1193(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1321(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1543(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1192[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1193, x64Parser::tokenBranches1193 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1321, x64Parser::tokenBranches1321 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1543, x64Parser::tokenBranches1543 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc478(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 51; +} +x64Token x64Parser::tokenBranches477[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc478, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches616 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1192 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc630(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; +} +x64Token x64Parser::tokenBranches629[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc630, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc754(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 76; +} +x64Token x64Parser::tokenBranches753[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc754, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc878(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 90; +} +x64Token x64Parser::tokenBranches877[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc878, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc629(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc753(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc877(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches628[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc629, x64Parser::tokenBranches629 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc753, x64Parser::tokenBranches753 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc877, x64Parser::tokenBranches877 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc486(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; +} +x64Token x64Parser::tokenBranches485[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc486, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches628 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc623, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc747(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches746[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc747, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc871(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches870[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc871, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2262(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; +} +x64Token x64Parser::tokenBranches2261[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2262, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2794(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 210; +} +x64Token x64Parser::tokenBranches2793[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2794, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3092(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 236; +} +x64Token x64Parser::tokenBranches3091[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3092, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2261(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2793(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3091(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2260[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2261, x64Parser::tokenBranches2261 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2793, x64Parser::tokenBranches2793 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3091, x64Parser::tokenBranches3091 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2514(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; +} +x64Token x64Parser::tokenBranches2259[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2260 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2514, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2259(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2258[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2259, x64Parser::tokenBranches2259 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2269(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2268[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2269, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2801(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 211; +} +x64Token x64Parser::tokenBranches2800[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2801, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3099(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 237; +} +x64Token x64Parser::tokenBranches3098[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3099, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2268(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2800(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3098(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2267[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2268, x64Parser::tokenBranches2268 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2800, x64Parser::tokenBranches2800 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3098, x64Parser::tokenBranches3098 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2519(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2257[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2258 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2267 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2519, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc622(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc746(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc870(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2257(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches484[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches485 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc622, x64Parser::tokenBranches622 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc746, x64Parser::tokenBranches746 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc870, x64Parser::tokenBranches870 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2257, x64Parser::tokenBranches2257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1595(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1594[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1595, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1602(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches1601[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1602, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1609(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches1608[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1609, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1594(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1601(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1608(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1593[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1594, x64Parser::tokenBranches1594 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1601, x64Parser::tokenBranches1601 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1608, x64Parser::tokenBranches1608 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1588(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1587[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1588, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1593 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1723(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; +} +x64Token x64Parser::tokenBranches1722[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1723, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 148; +} +x64Token x64Parser::tokenBranches1729[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1737(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 149; +} +x64Token x64Parser::tokenBranches1736[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1737, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1722(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1729(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1736(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1721[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1722, x64Parser::tokenBranches1722 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1729, x64Parser::tokenBranches1729 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1736, x64Parser::tokenBranches1736 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1716(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; +} +x64Token x64Parser::tokenBranches1715[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1716, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1721 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1851(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1850[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1851, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1858(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 157; +} +x64Token x64Parser::tokenBranches1857[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1858, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1874(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1873[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1874, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1883(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 159; +} +x64Token x64Parser::tokenBranches1882[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1883, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1873(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1882(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1872[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1873, x64Parser::tokenBranches1873 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1882, x64Parser::tokenBranches1882 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1865(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1864[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1865, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1872 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1850(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1857(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1849[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1864 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1850, x64Parser::tokenBranches1850 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1857, x64Parser::tokenBranches1857 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1844(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1843[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1844, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1849 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1587(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1715(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1843(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1586[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1587, x64Parser::tokenBranches1587 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1715, x64Parser::tokenBranches1715 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1843, x64Parser::tokenBranches1843 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc481(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches480[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc481, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches484 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1586 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc560(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 63; +} +x64Token x64Parser::tokenBranches559[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc560, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3261(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 244; +} +x64Token x64Parser::tokenBranches3260[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3261, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3351(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 261; +} +x64Token x64Parser::tokenBranches3350[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3351, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3443(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 275; +} +x64Token x64Parser::tokenBranches3442[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3443, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4515(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 373; +} +x64Token x64Parser::tokenBranches4514[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4515, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4891(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 397; +} +x64Token x64Parser::tokenBranches4890[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4891, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5103(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 421; +} +x64Token x64Parser::tokenBranches5102[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5103, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4514(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4890(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5102(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4513[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4514, x64Parser::tokenBranches4514 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4890, x64Parser::tokenBranches4890 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5102, x64Parser::tokenBranches5102 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4713(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 373; +} +x64Token x64Parser::tokenBranches4512[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4513 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4713, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4512(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4511[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4512, x64Parser::tokenBranches4512 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4522(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 374; +} +x64Token x64Parser::tokenBranches4521[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4522, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4898(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 398; +} +x64Token x64Parser::tokenBranches4897[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4898, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 422; +} +x64Token x64Parser::tokenBranches5109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4521(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4897(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5109(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4520[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4521, x64Parser::tokenBranches4521 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4897, x64Parser::tokenBranches4897 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5109, x64Parser::tokenBranches5109 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4718(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 374; +} +x64Token x64Parser::tokenBranches4510[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4511 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4520 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4718, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3260(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3350(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3442(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4510(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3259[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3260, x64Parser::tokenBranches3260 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3350, x64Parser::tokenBranches3350 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3442, x64Parser::tokenBranches3442 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4510, x64Parser::tokenBranches4510 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3182(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 244; +} +x64Token x64Parser::tokenBranches3181[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3182, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3259 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3307(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 253; +} +x64Token x64Parser::tokenBranches3306[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3307, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3399(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 269; +} +x64Token x64Parser::tokenBranches3398[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3399, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3491(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 283; +} +x64Token x64Parser::tokenBranches3490[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3491, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3306(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3398(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3490(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3305[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3306, x64Parser::tokenBranches3306 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3398, x64Parser::tokenBranches3398 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3490, x64Parser::tokenBranches3490 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3219(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 253; +} +x64Token x64Parser::tokenBranches3218[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3219, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3356(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 262; +} +x64Token x64Parser::tokenBranches3355[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3356, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3448(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 276; +} +x64Token x64Parser::tokenBranches3447[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3448, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4531(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 375; +} +x64Token x64Parser::tokenBranches4530[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4531, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4907(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 399; +} +x64Token x64Parser::tokenBranches4906[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4907, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5119(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 423; +} +x64Token x64Parser::tokenBranches5118[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5119, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4530(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4906(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5118(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4529[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4530, x64Parser::tokenBranches4530 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4906, x64Parser::tokenBranches4906 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5118, x64Parser::tokenBranches5118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4725(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 375; +} +x64Token x64Parser::tokenBranches4528[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4529 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4725, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4528(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4527[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4528, x64Parser::tokenBranches4528 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4538(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 376; +} +x64Token x64Parser::tokenBranches4537[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4538, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4914(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 400; +} +x64Token x64Parser::tokenBranches4913[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4914, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5126(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 424; +} +x64Token x64Parser::tokenBranches5125[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5126, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4537(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4913(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5125(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4536[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4537, x64Parser::tokenBranches4537 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4913, x64Parser::tokenBranches4913 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5125, x64Parser::tokenBranches5125 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 376; +} +x64Token x64Parser::tokenBranches4526[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4527 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4536 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3355(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3447(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4526(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3217[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3218 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3355, x64Parser::tokenBranches3355 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3447, x64Parser::tokenBranches3447 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4526, x64Parser::tokenBranches4526 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3265, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3542(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3541[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3542, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3549(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 262; +} +x64Token x64Parser::tokenBranches3548[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3549, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3556(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 276; +} +x64Token x64Parser::tokenBranches3555[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3556, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3541(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3548(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3555(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3540[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3541, x64Parser::tokenBranches3541 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3548, x64Parser::tokenBranches3548 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3555, x64Parser::tokenBranches3555 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3535(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3534[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3535, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3540 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3602(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 292; +} +x64Token x64Parser::tokenBranches3601[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3602, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3609(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 293; +} +x64Token x64Parser::tokenBranches3608[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3609, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3616(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 294; +} +x64Token x64Parser::tokenBranches3615[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3616, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3601(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3608(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3615(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3600[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3601, x64Parser::tokenBranches3601 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3608, x64Parser::tokenBranches3608 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3615, x64Parser::tokenBranches3615 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3595(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 292; +} +x64Token x64Parser::tokenBranches3594[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3595, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3600 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3662(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 299; +} +x64Token x64Parser::tokenBranches3661[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3662, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3661(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3660[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3661, x64Parser::tokenBranches3661 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3655(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 298; +} +x64Token x64Parser::tokenBranches3654[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3655, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3660 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3690(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 303; +} +x64Token x64Parser::tokenBranches3689[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3690, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3689(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3688[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3689, x64Parser::tokenBranches3689 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3683(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 302; +} +x64Token x64Parser::tokenBranches3682[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3683, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3688 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3534(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3594(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3654(x64Operand &operand, int tokenPos) +{ + operand.values[13] = new Coding[2]; + CleanupValues.push_back(operand.values[13]); + operand.values[13]->type = Coding::number; + operand.values[13]->val = operands.size(); + operand.values[13]->bits = 0; + operand.values[13]->field = 0; + operand.values[13]->unary = 0; + operand.values[13]->binary = 0; + operand.values[13][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3682(x64Operand &operand, int tokenPos) +{ + operand.values[14] = new Coding[2]; + CleanupValues.push_back(operand.values[14]); + operand.values[14]->type = Coding::number; + operand.values[14]->val = operands.size(); + operand.values[14]->bits = 0; + operand.values[14]->field = 0; + operand.values[14]->unary = 0; + operand.values[14]->binary = 0; + operand.values[14][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3533[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3534, x64Parser::tokenBranches3534 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3594, x64Parser::tokenBranches3594 }, + {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3654, x64Parser::tokenBranches3654 }, + {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3682, x64Parser::tokenBranches3682 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3185(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +void x64Parser::TokenFunc3264(x64Operand &operand, int tokenPos) +{ + operand.values[12] = new Coding[2]; + CleanupValues.push_back(operand.values[12]); + operand.values[12]->type = Coding::number; + operand.values[12]->val = operands.size(); + operand.values[12]->bits = 0; + operand.values[12]->field = 0; + operand.values[12]->unary = 0; + operand.values[12]->binary = 0; + operand.values[12][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3184[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3185, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3217 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3264, x64Parser::tokenBranches3264 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3533 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3270(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 246; +} +x64Token x64Parser::tokenBranches3269[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3270, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3361(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 263; +} +x64Token x64Parser::tokenBranches3360[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3361, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3453(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 277; +} +x64Token x64Parser::tokenBranches3452[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3453, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4465(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 367; +} +x64Token x64Parser::tokenBranches4464[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4465, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4841(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 391; +} +x64Token x64Parser::tokenBranches4840[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4841, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5053(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 415; +} +x64Token x64Parser::tokenBranches5052[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5053, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4464(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4840(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5052(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4463[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4464, x64Parser::tokenBranches4464 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4840, x64Parser::tokenBranches4840 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5052, x64Parser::tokenBranches5052 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4675(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 367; +} +x64Token x64Parser::tokenBranches4462[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4463 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4675, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4499(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 371; +} +x64Token x64Parser::tokenBranches4498[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4499, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4875(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 395; +} +x64Token x64Parser::tokenBranches4874[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4875, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5087(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 419; +} +x64Token x64Parser::tokenBranches5086[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5087, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4498(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4874(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5086(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4497[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4498, x64Parser::tokenBranches4498 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4874, x64Parser::tokenBranches4874 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5086, x64Parser::tokenBranches5086 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4701(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 371; +} +x64Token x64Parser::tokenBranches4496[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4497 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4701, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4496(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4495[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4496, x64Parser::tokenBranches4496 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4506(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 372; +} +x64Token x64Parser::tokenBranches4505[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4506, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4882(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 396; +} +x64Token x64Parser::tokenBranches4881[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4882, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5094(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 420; +} +x64Token x64Parser::tokenBranches5093[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5094, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4505(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4881(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5093(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4504[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4505, x64Parser::tokenBranches4505 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4881, x64Parser::tokenBranches4881 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5093, x64Parser::tokenBranches5093 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4706(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 372; +} +x64Token x64Parser::tokenBranches4494[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4495 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4504 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4706, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3269(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3360(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3452(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4494(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3268[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4462 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3269, x64Parser::tokenBranches3269 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3360, x64Parser::tokenBranches3360 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3452, x64Parser::tokenBranches3452 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4494, x64Parser::tokenBranches4494 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3718(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3717[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3718, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3725(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 307; +} +x64Token x64Parser::tokenBranches3724[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3725, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3732(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 308; +} +x64Token x64Parser::tokenBranches3731[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3732, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3717(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3724(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3731(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3716[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3717, x64Parser::tokenBranches3717 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3724, x64Parser::tokenBranches3724 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3731, x64Parser::tokenBranches3731 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3711(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3710[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3711, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3716 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3846(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3845[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3846, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3853(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 316; +} +x64Token x64Parser::tokenBranches3852[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3853, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3860(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 317; +} +x64Token x64Parser::tokenBranches3859[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3860, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3845(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3852(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3859(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3844[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3845, x64Parser::tokenBranches3845 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3852, x64Parser::tokenBranches3852 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3859, x64Parser::tokenBranches3859 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3839(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3838[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3839, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3844 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4230(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 343; +} +x64Token x64Parser::tokenBranches4229[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4230, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4229(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4228[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4229, x64Parser::tokenBranches4229 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4223(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 342; +} +x64Token x64Parser::tokenBranches4222[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4223, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4228 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3710(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3838(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4222(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3709[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3710, x64Parser::tokenBranches3710 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3838, x64Parser::tokenBranches3838 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4222, x64Parser::tokenBranches4222 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3188(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 246; +} +x64Token x64Parser::tokenBranches3187[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3188, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3268 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3709 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3295(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 247; +} +x64Token x64Parser::tokenBranches3294[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3295, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3387(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 267; +} +x64Token x64Parser::tokenBranches3386[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3479(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 281; +} +x64Token x64Parser::tokenBranches3478[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3479, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 368; +} +x64Token x64Parser::tokenBranches4471[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4472, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4848(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 392; +} +x64Token x64Parser::tokenBranches4847[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4848, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5060(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 416; +} +x64Token x64Parser::tokenBranches5059[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5060, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4471(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4847(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5059(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4470[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4471, x64Parser::tokenBranches4471 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4847, x64Parser::tokenBranches4847 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5059, x64Parser::tokenBranches5059 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4680(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 368; +} +x64Token x64Parser::tokenBranches4469[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4470 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4680, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4607(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 383; +} +x64Token x64Parser::tokenBranches4606[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4607, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4983(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 407; +} +x64Token x64Parser::tokenBranches4982[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4983, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5195(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 431; +} +x64Token x64Parser::tokenBranches5194[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5195, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4606(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4982(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5194(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4605[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4606, x64Parser::tokenBranches4606 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4982, x64Parser::tokenBranches4982 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5194, x64Parser::tokenBranches5194 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4785(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 383; +} +x64Token x64Parser::tokenBranches4604[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4605 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4785, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4604(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4603[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4604, x64Parser::tokenBranches4604 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4614(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 384; +} +x64Token x64Parser::tokenBranches4613[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4614, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4990(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 408; +} +x64Token x64Parser::tokenBranches4989[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4990, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5202(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 432; +} +x64Token x64Parser::tokenBranches5201[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5202, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4613(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4989(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5201(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4612[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4613, x64Parser::tokenBranches4613 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4989, x64Parser::tokenBranches4989 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5201, x64Parser::tokenBranches5201 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4790(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 384; +} +x64Token x64Parser::tokenBranches4602[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4603 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4612 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4790, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3294(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3386(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3478(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4602(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3293[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4469 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3294, x64Parser::tokenBranches3294 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3386, x64Parser::tokenBranches3386 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3478, x64Parser::tokenBranches3478 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4602, x64Parser::tokenBranches4602 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3974(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches3973[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3974, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3981(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 325; +} +x64Token x64Parser::tokenBranches3980[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3981, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3988(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 326; +} +x64Token x64Parser::tokenBranches3987[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3988, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3973(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3980(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3987(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3972[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3973, x64Parser::tokenBranches3973 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3980, x64Parser::tokenBranches3980 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3987, x64Parser::tokenBranches3987 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3967(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches3966[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3967, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3972 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4102(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4101[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4102, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4109(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 334; +} +x64Token x64Parser::tokenBranches4108[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4109, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4116(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 335; +} +x64Token x64Parser::tokenBranches4115[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4116, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4101(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4108(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4115(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4100[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4101, x64Parser::tokenBranches4101 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4108, x64Parser::tokenBranches4108 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4115, x64Parser::tokenBranches4115 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4095(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4094[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4095, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4100 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4258(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 347; +} +x64Token x64Parser::tokenBranches4257[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4258, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4257(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4256[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4257, x64Parser::tokenBranches4257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4251(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 346; +} +x64Token x64Parser::tokenBranches4250[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4251, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4256 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3966(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4094(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4250(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3965[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3966, x64Parser::tokenBranches3966 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4094, x64Parser::tokenBranches4094 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4250, x64Parser::tokenBranches4250 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 247; +} +x64Token x64Parser::tokenBranches3190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3191, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3293 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3965 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3314(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 254; +} +x64Token x64Parser::tokenBranches3313[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3314, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3406(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 270; +} +x64Token x64Parser::tokenBranches3405[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3406, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3498(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 284; +} +x64Token x64Parser::tokenBranches3497[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3498, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3313(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3405(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3497(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3312[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3313, x64Parser::tokenBranches3313 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3405, x64Parser::tokenBranches3405 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3497, x64Parser::tokenBranches3497 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3224(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 254; +} +x64Token x64Parser::tokenBranches3223[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3224, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3312 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches3299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3392(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 268; +} +x64Token x64Parser::tokenBranches3391[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3392, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3484(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 282; +} +x64Token x64Parser::tokenBranches3483[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3484, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 385; +} +x64Token x64Parser::tokenBranches4622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4623, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4999(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 409; +} +x64Token x64Parser::tokenBranches4998[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4999, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5211(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 433; +} +x64Token x64Parser::tokenBranches5210[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5211, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4622(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4998(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5210(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4621[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4622, x64Parser::tokenBranches4622 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4998, x64Parser::tokenBranches4998 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5210, x64Parser::tokenBranches5210 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4797(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 385; +} +x64Token x64Parser::tokenBranches4620[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4621 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4797, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4620(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4619[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4620, x64Parser::tokenBranches4620 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4630(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 386; +} +x64Token x64Parser::tokenBranches4629[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4630, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5006(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 410; +} +x64Token x64Parser::tokenBranches5005[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5006, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 434; +} +x64Token x64Parser::tokenBranches5217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4629(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5005(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5217(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4628[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4629, x64Parser::tokenBranches4629 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5005, x64Parser::tokenBranches5005 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5217, x64Parser::tokenBranches5217 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4802(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 386; +} +x64Token x64Parser::tokenBranches4618[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4619 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4628 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4802, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3299(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3391(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3483(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4618(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3222[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3223 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3299, x64Parser::tokenBranches3299 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3391, x64Parser::tokenBranches3391 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3483, x64Parser::tokenBranches3483 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4618, x64Parser::tokenBranches4618 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4286(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches4285[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4286, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4293(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 268; +} +x64Token x64Parser::tokenBranches4292[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4293, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 282; +} +x64Token x64Parser::tokenBranches4299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4285(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4292(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4299(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4284[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4285, x64Parser::tokenBranches4285 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4292, x64Parser::tokenBranches4292 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4299, x64Parser::tokenBranches4299 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4279(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches4278[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4279, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4284 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 353; +} +x64Token x64Parser::tokenBranches4345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4353(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 354; +} +x64Token x64Parser::tokenBranches4352[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4353, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4360(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 355; +} +x64Token x64Parser::tokenBranches4359[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4360, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4345(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4352(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4359(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4344[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4345, x64Parser::tokenBranches4345 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4352, x64Parser::tokenBranches4352 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4359, x64Parser::tokenBranches4359 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4339(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 353; +} +x64Token x64Parser::tokenBranches4338[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4339, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4344 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4406(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 360; +} +x64Token x64Parser::tokenBranches4405[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4406, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4422(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 362; +} +x64Token x64Parser::tokenBranches4421[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4422, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4421(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4420[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4421, x64Parser::tokenBranches4421 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4413(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 361; +} +x64Token x64Parser::tokenBranches4412[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4413, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4420 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4405(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4404[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4412 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4405, x64Parser::tokenBranches4405 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4399(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 359; +} +x64Token x64Parser::tokenBranches4398[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4399, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4404 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4278(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4338(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4398(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4277[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4278, x64Parser::tokenBranches4278 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4338, x64Parser::tokenBranches4338 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4398, x64Parser::tokenBranches4398 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3214(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches3213[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3214, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3222 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3248(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 258; +} +x64Token x64Parser::tokenBranches3247[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3248, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3247(x64Operand &operand, int tokenPos) +{ + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3246[] = { + {x64Token::NUMBER, 15, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3247, x64Parser::tokenBranches3247 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3245[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3246 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3251(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 259; +} +x64Token x64Parser::tokenBranches3250[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3251, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc16(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc73(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc480(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc559(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3213(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc3250(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2[] = { + {x64Token::REGISTER, 96, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches6 }, + {x64Token::REGISTER, 95, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches11 }, + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches21 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches26 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches471 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches474 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches477 }, + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3181 }, + {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3184 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3187 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3190 }, + {x64Token::REGISTER, 68, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3245 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc3, x64Parser::tokenBranches3 }, + {x64Token::REGISTERCLASS, 19, 0, 0, x64Parser::RegClassData1, &x64Parser::TokenFunc16, x64Parser::tokenBranches16 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc73, x64Parser::tokenBranches73 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc480, x64Parser::tokenBranches480 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc559, x64Parser::tokenBranches559 }, + {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3213, x64Parser::tokenBranches3213 }, + {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3250, x64Parser::tokenBranches3250 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5259(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 439; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5260(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5261(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 441; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5262(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5263(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5264(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 442; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5266(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches1[] = { + {x64Token::TOKEN, 1, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches2 }, + {x64Token::REGISTERCLASS, 20, 1, 0, x64Parser::RegClassData6, &x64Parser::TokenFunc5259, }, + {x64Token::REGISTERCLASS, 1, 1, 0, x64Parser::RegClassData7, &x64Parser::TokenFunc5260, }, + {x64Token::REGISTERCLASS, 14, 1, 0, x64Parser::RegClassData8, &x64Parser::TokenFunc5261, }, + {x64Token::REGISTERCLASS, 4, 1, 0, x64Parser::RegClassData9, &x64Parser::TokenFunc5262, }, + {x64Token::REGISTERCLASS, 7, 1, 0, x64Parser::RegClassData10, &x64Parser::TokenFunc5263, }, + {x64Token::REGISTERCLASS, 10, 1, 0, x64Parser::RegClassData11, &x64Parser::TokenFunc5264, }, + {x64Token::REGISTERCLASS, 18, 1, 0, x64Parser::RegClassData12, &x64Parser::TokenFunc5265, }, + {x64Token::REGISTERCLASS, 17, 1, 0, x64Parser::RegClassData13, &x64Parser::TokenFunc5266, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5268(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 443; +} +x64Token x64Parser::tokenBranches5267[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5268, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5270(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 444; +} +x64Token x64Parser::tokenBranches5269[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5270, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5275_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5275(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5275_16; + operand.values[17] = tokenCoding5275_17; + operand.values[18] = tokenCoding5275_18; + operand.values[19] = tokenCoding5275_19; +} +Coding x64Parser::tokenCoding5287_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5287(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5287_16; + operand.values[17] = tokenCoding5287_17; + operand.values[18] = tokenCoding5287_18; + operand.values[19] = tokenCoding5287_19; +} +x64Token x64Parser::tokenBranches5274[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5275, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5287, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5273[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5272[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5273 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5279_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5279(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5279_16; + operand.values[17] = tokenCoding5279_17; + operand.values[18] = tokenCoding5279_18; + operand.values[19] = tokenCoding5279_19; +} +Coding x64Parser::tokenCoding5291_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5291(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5291_16; + operand.values[17] = tokenCoding5291_17; + operand.values[18] = tokenCoding5291_18; + operand.values[19] = tokenCoding5291_19; +} +x64Token x64Parser::tokenBranches5278[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5279, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5291, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5277[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5276[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5277 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5283_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5283(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5283_16; + operand.values[17] = tokenCoding5283_17; + operand.values[18] = tokenCoding5283_18; + operand.values[19] = tokenCoding5283_19; +} +Coding x64Parser::tokenCoding5295_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5295(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5295_16; + operand.values[17] = tokenCoding5295_17; + operand.values[18] = tokenCoding5295_18; + operand.values[19] = tokenCoding5295_19; +} +x64Token x64Parser::tokenBranches5282[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5283, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5295, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5281[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5280[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5281 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5272(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5276(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5280(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5271[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5272, x64Parser::tokenBranches5272 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5276, x64Parser::tokenBranches5276 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5280, x64Parser::tokenBranches5280 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5300_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding5300_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5300_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5300_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5300(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5300_16; + operand.values[17] = tokenCoding5300_17; + operand.values[18] = tokenCoding5300_18; + operand.values[19] = tokenCoding5300_19; +} +x64Token x64Parser::tokenBranches5299[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5300, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5298[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5299 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5298 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5304_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5304(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5304_16; + operand.values[17] = tokenCoding5304_17; + operand.values[18] = tokenCoding5304_18; + operand.values[19] = tokenCoding5304_19; +} +x64Token x64Parser::tokenBranches5303[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5304, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5302[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5303 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5301[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5302 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5308_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5308(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5308_16; + operand.values[17] = tokenCoding5308_17; + operand.values[18] = tokenCoding5308_18; + operand.values[19] = tokenCoding5308_19; +} +x64Token x64Parser::tokenBranches5307[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5308, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5306[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5307 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5306 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5297(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5301(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5305(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5296[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5297, x64Parser::tokenBranches5297 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5301, x64Parser::tokenBranches5301 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5305, x64Parser::tokenBranches5305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5313(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 445; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5312[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5313, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5311[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5312 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5310[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5311 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5317(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 446; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5316[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5317, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5315[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5316 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5321(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 447; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5320[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5321, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5319[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5320 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5318[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5319 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5325(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 448; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5324[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5325, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5323[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5324 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5322[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5323 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5329_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5329(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5329_16; + operand.values[17] = tokenCoding5329_17; + operand.values[18] = tokenCoding5329_18; + operand.values[19] = tokenCoding5329_19; +} +x64Token x64Parser::tokenBranches5328[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5329, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5327[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5328 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5327 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5333_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5333(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5333_16; + operand.values[17] = tokenCoding5333_17; + operand.values[23] = tokenCoding5333_23; + operand.values[18] = tokenCoding5333_18; + operand.values[19] = tokenCoding5333_19; +} +x64Token x64Parser::tokenBranches5332[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5333, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5331[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5332 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5330[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5331 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5337_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5337(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5337_16; + operand.values[17] = tokenCoding5337_17; + operand.values[18] = tokenCoding5337_18; + operand.values[19] = tokenCoding5337_19; +} +x64Token x64Parser::tokenBranches5336[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5337, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5335[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5336 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5334[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5335 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5341_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5341(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5341_16; + operand.values[17] = tokenCoding5341_17; + operand.values[18] = tokenCoding5341_18; + operand.values[19] = tokenCoding5341_19; +} +x64Token x64Parser::tokenBranches5340[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5341, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5339[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5340 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5338[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5339 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5345_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5345(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5345_16; + operand.values[17] = tokenCoding5345_17; + operand.values[18] = tokenCoding5345_18; + operand.values[19] = tokenCoding5345_19; +} +x64Token x64Parser::tokenBranches5344[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5345, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5343[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5344 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5342[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5343 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5349_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5349(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5349_16; + operand.values[17] = tokenCoding5349_17; + operand.values[18] = tokenCoding5349_18; + operand.values[19] = tokenCoding5349_19; +} +Coding x64Parser::tokenCoding5353_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5353(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5353_16; + operand.values[17] = tokenCoding5353_17; + operand.values[23] = tokenCoding5353_23; + operand.values[18] = tokenCoding5353_18; + operand.values[19] = tokenCoding5353_19; +} +x64Token x64Parser::tokenBranches5348[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5349, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5353, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5347[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5348 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5346[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5347 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5357_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5357(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5357_16; + operand.values[17] = tokenCoding5357_17; + operand.values[18] = tokenCoding5357_18; + operand.values[19] = tokenCoding5357_19; +} +x64Token x64Parser::tokenBranches5356[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5357, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5355[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5356 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5354[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5355 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5361_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5361(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5361_16; + operand.values[17] = tokenCoding5361_17; + operand.values[18] = tokenCoding5361_18; + operand.values[19] = tokenCoding5361_19; +} +x64Token x64Parser::tokenBranches5360[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5361, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5359[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5360 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5358[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5359 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5365_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5365(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5365_16; + operand.values[17] = tokenCoding5365_17; + operand.values[18] = tokenCoding5365_18; + operand.values[19] = tokenCoding5365_19; +} +x64Token x64Parser::tokenBranches5364[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5365, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5363[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5364 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5362[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5363 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5370_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5370_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5370_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5370(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5370_16; + operand.values[17] = tokenCoding5370_17; + operand.values[19] = tokenCoding5370_19; +} +x64Token x64Parser::tokenBranches5369[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5370, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5368[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5369 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5367[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5368 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5366[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5367 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5375_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5375_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5375_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5375(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5375_16; + operand.values[17] = tokenCoding5375_17; + operand.values[19] = tokenCoding5375_19; +} +x64Token x64Parser::tokenBranches5374[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5375, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5380_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5380_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5380_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5380(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5380_16; + operand.values[17] = tokenCoding5380_17; + operand.values[19] = tokenCoding5380_19; +} +Coding x64Parser::tokenCoding5385_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5385_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5385_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5385(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 451; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5385_16; + operand.values[17] = tokenCoding5385_17; + operand.values[19] = tokenCoding5385_19; +} +x64Token x64Parser::tokenBranches5379[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5380, }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5385, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5373[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5374 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5379 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5372[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5373 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5371[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5372 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5390_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5390_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5390_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5390(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5390_16; + operand.values[17] = tokenCoding5390_17; + operand.values[19] = tokenCoding5390_19; +} +x64Token x64Parser::tokenBranches5389[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5390, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5395_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5395_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5395_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5395(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5395_16; + operand.values[17] = tokenCoding5395_17; + operand.values[19] = tokenCoding5395_19; +} +x64Token x64Parser::tokenBranches5394[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5395, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5400_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5400_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5400_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5400(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5400_16; + operand.values[17] = tokenCoding5400_17; + operand.values[19] = tokenCoding5400_19; +} +Coding x64Parser::tokenCoding5405_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5405_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5405_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5405(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5405_16; + operand.values[17] = tokenCoding5405_17; + operand.values[19] = tokenCoding5405_19; +} +x64Token x64Parser::tokenBranches5399[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5400, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5405, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5388[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5389 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5394 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5399 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5387[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5388 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5386[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5387 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5410_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5410_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5410_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5410(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5410_16; + operand.values[17] = tokenCoding5410_17; + operand.values[19] = tokenCoding5410_19; +} +x64Token x64Parser::tokenBranches5409[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5410, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5415_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5415_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5415_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5415(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5415_16; + operand.values[17] = tokenCoding5415_17; + operand.values[19] = tokenCoding5415_19; +} +x64Token x64Parser::tokenBranches5414[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5415, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5420_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5420_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5420_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5420(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5420_16; + operand.values[17] = tokenCoding5420_17; + operand.values[19] = tokenCoding5420_19; +} +x64Token x64Parser::tokenBranches5419[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5420, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5425_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5425_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5425_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5425(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5425_16; + operand.values[17] = tokenCoding5425_17; + operand.values[19] = tokenCoding5425_19; +} +Coding x64Parser::tokenCoding5430_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5430_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5430_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5430(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5430_16; + operand.values[17] = tokenCoding5430_17; + operand.values[19] = tokenCoding5430_19; +} +x64Token x64Parser::tokenBranches5424[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5425, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5430, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5408[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5409 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5414 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5419 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5424 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5407[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5408 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5406[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5407 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5434_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5434_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5434_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5434(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5434_16; + operand.values[17] = tokenCoding5434_17; + operand.values[19] = tokenCoding5434_19; +} +x64Token x64Parser::tokenBranches5433[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5434, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5432[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5433 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5431[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5432 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5438_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5438_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5438_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5438(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5438_16; + operand.values[17] = tokenCoding5438_17; + operand.values[19] = tokenCoding5438_19; +} +x64Token x64Parser::tokenBranches5437[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5438, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5442_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5442_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5442_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5442(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5442_16; + operand.values[17] = tokenCoding5442_17; + operand.values[19] = tokenCoding5442_19; +} +Coding x64Parser::tokenCoding5446_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5446_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5446_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5446(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 451; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5446_16; + operand.values[17] = tokenCoding5446_17; + operand.values[19] = tokenCoding5446_19; +} +x64Token x64Parser::tokenBranches5441[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5442, }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5446, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5436[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5437 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5441 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5435[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5436 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5450_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5450_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5450_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5450(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5450_16; + operand.values[17] = tokenCoding5450_17; + operand.values[19] = tokenCoding5450_19; +} +x64Token x64Parser::tokenBranches5449[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5450, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5454_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5454_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5454_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5454(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5454_16; + operand.values[17] = tokenCoding5454_17; + operand.values[19] = tokenCoding5454_19; +} +x64Token x64Parser::tokenBranches5453[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5454, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5458_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5458_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5458_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5458(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5458_16; + operand.values[17] = tokenCoding5458_17; + operand.values[19] = tokenCoding5458_19; +} +Coding x64Parser::tokenCoding5462_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5462_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5462_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5462(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5462_16; + operand.values[17] = tokenCoding5462_17; + operand.values[19] = tokenCoding5462_19; +} +x64Token x64Parser::tokenBranches5457[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5458, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5462, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5448[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5449 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5453 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5457 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5447[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5448 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5466_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5466_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5466_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5466(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5466_16; + operand.values[17] = tokenCoding5466_17; + operand.values[19] = tokenCoding5466_19; +} +x64Token x64Parser::tokenBranches5465[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5466, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5470_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5470_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5470_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5470(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5470_16; + operand.values[17] = tokenCoding5470_17; + operand.values[19] = tokenCoding5470_19; +} +x64Token x64Parser::tokenBranches5469[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5470, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5474_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5474_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5474_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5474(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5474_16; + operand.values[17] = tokenCoding5474_17; + operand.values[19] = tokenCoding5474_19; +} +x64Token x64Parser::tokenBranches5473[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5474, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5478_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5478_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5478_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5478(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5478_16; + operand.values[17] = tokenCoding5478_17; + operand.values[19] = tokenCoding5478_19; +} +Coding x64Parser::tokenCoding5482_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5482_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5482_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5482(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 455; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5482_16; + operand.values[17] = tokenCoding5482_17; + operand.values[19] = tokenCoding5482_19; +} +x64Token x64Parser::tokenBranches5477[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5478, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5482, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5464[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5465 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5469 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5473 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5477 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5463[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5464 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5326(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5330(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5334(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5338(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5342(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5309[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches5310 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5314 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5318 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5322 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc5326, x64Parser::tokenBranches5326 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc5330, x64Parser::tokenBranches5330 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5334, x64Parser::tokenBranches5334 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5338, x64Parser::tokenBranches5338 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5342, x64Parser::tokenBranches5342 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5346 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5354 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5358 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5362 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5366 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5371 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5386 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5406 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5431 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5435 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5447 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5463 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5488_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5488_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5488_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5488(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 456; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5488_16; + operand.values[17] = tokenCoding5488_17; + operand.values[19] = tokenCoding5488_19; +} +x64Token x64Parser::tokenBranches5487[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5488, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5502_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5502(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5502_16; + operand.values[17] = tokenCoding5502_17; + operand.values[18] = tokenCoding5502_18; + operand.values[19] = tokenCoding5502_19; +} +x64Token x64Parser::tokenBranches5486[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5487 }, + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5502, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5485[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5486 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5484[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5485 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5493_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5493_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5493_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5493(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 457; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5493_16; + operand.values[17] = tokenCoding5493_17; + operand.values[19] = tokenCoding5493_19; +} +x64Token x64Parser::tokenBranches5492[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5493, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5506_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5506(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5506_16; + operand.values[17] = tokenCoding5506_17; + operand.values[18] = tokenCoding5506_18; + operand.values[19] = tokenCoding5506_19; +} +x64Token x64Parser::tokenBranches5491[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5492 }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5506, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5490[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5491 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5489[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5490 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5498_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5498_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5498_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5498(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 458; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5498_16; + operand.values[17] = tokenCoding5498_17; + operand.values[19] = tokenCoding5498_19; +} +x64Token x64Parser::tokenBranches5497[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5498, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5510_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5510(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5510_16; + operand.values[17] = tokenCoding5510_17; + operand.values[18] = tokenCoding5510_18; + operand.values[19] = tokenCoding5510_19; +} +x64Token x64Parser::tokenBranches5496[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5497 }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5510, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5495[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5496 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5494[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5495 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5483[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5484 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5489 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5494 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5520_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5520_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5520_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5520(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5520_16; + operand.values[17] = tokenCoding5520_17; + operand.values[19] = tokenCoding5520_19; +} +x64Token x64Parser::tokenBranches5519[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5520, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5522_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5522_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5522_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5522(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5522_16; + operand.values[17] = tokenCoding5522_17; + operand.values[19] = tokenCoding5522_19; +} +x64Token x64Parser::tokenBranches5521[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5522, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5524_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5524_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5524_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5524(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5524_16; + operand.values[17] = tokenCoding5524_17; + operand.values[19] = tokenCoding5524_19; +} +x64Token x64Parser::tokenBranches5523[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5524, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5526_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5526_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5526_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5526(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5526_16; + operand.values[17] = tokenCoding5526_17; + operand.values[19] = tokenCoding5526_19; +} +x64Token x64Parser::tokenBranches5525[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5526, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5512_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5512_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5512_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5512(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5512_16; + operand.values[17] = tokenCoding5512_17; + operand.values[19] = tokenCoding5512_19; +} +void x64Parser::TokenFunc5513(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 459; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5514(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 460; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5515(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 461; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +Coding x64Parser::tokenCoding5516_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5516_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5516_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5516(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5516_16; + operand.values[17] = tokenCoding5516_17; + operand.values[19] = tokenCoding5516_19; +} +Coding x64Parser::tokenCoding5517_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5517_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5517_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5517(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5517_16; + operand.values[17] = tokenCoding5517_17; + operand.values[19] = tokenCoding5517_19; +} +Coding x64Parser::tokenCoding5518_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5518_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5518_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5518(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5518_16; + operand.values[17] = tokenCoding5518_17; + operand.values[19] = tokenCoding5518_19; +} +x64Token x64Parser::tokenBranches5511[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5512, }, + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5513, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5514, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5515, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5516, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5517, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5518, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5519 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5521 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5523 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5525 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5533_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5533_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5533_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5533(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5533_16; + operand.values[17] = tokenCoding5533_17; + operand.values[19] = tokenCoding5533_19; +} +x64Token x64Parser::tokenBranches5532[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5533, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5535_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5535_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5535_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5535(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5535_16; + operand.values[17] = tokenCoding5535_17; + operand.values[19] = tokenCoding5535_19; +} +x64Token x64Parser::tokenBranches5534[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5535, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5537_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5537_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5537_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5537(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5537_16; + operand.values[17] = tokenCoding5537_17; + operand.values[19] = tokenCoding5537_19; +} +x64Token x64Parser::tokenBranches5536[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5537, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5539_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5539_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5539_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5539(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5539_16; + operand.values[17] = tokenCoding5539_17; + operand.values[19] = tokenCoding5539_19; +} +x64Token x64Parser::tokenBranches5538[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5539, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5528_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5528_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5528_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5528(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5528_16; + operand.values[17] = tokenCoding5528_17; + operand.values[19] = tokenCoding5528_19; +} +Coding x64Parser::tokenCoding5529_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5529_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5529_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5529(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5529_16; + operand.values[17] = tokenCoding5529_17; + operand.values[19] = tokenCoding5529_19; +} +Coding x64Parser::tokenCoding5530_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5530_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5530_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5530(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5530_16; + operand.values[17] = tokenCoding5530_17; + operand.values[19] = tokenCoding5530_19; +} +Coding x64Parser::tokenCoding5531_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5531_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5531_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5531(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5531_16; + operand.values[17] = tokenCoding5531_17; + operand.values[19] = tokenCoding5531_19; +} +x64Token x64Parser::tokenBranches5527[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5528, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5529, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5530, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5531, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5532 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5534 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5536 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5538 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5543(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5542[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5543, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5541[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5542 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5546(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 463; +} +x64Token x64Parser::tokenBranches5545[] = { + {x64Token::REGISTER, 99, 1, 0, NULL,&x64Parser::TokenFunc5546, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5544[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5545 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5549_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5549_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5549_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5549(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5549_16; + operand.values[17] = tokenCoding5549_17; + operand.values[19] = tokenCoding5549_19; +} +x64Token x64Parser::tokenBranches5548[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc5549, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5551_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5551_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5551_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5551_16; + operand.values[17] = tokenCoding5551_17; + operand.values[19] = tokenCoding5551_19; +} +x64Token x64Parser::tokenBranches5550[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc5551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5544(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5540[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches5541 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5544, x64Parser::tokenBranches5544 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5548 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5550 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5555(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 439; +} +x64Token x64Parser::tokenBranches5554[] = { + {x64Token::REGISTER, 99, 1, 0, NULL,&x64Parser::TokenFunc5555, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5553[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5554 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5553(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 439; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5557(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 464; +} +x64Token x64Parser::tokenBranches5552[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5553, x64Parser::tokenBranches5553 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5557, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5560_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5560_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5560_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5560(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5560_16; + operand.values[17] = tokenCoding5560_17; + operand.values[19] = tokenCoding5560_19; +} +x64Token x64Parser::tokenBranches5559[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5560, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5562_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5562_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5562_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5562(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5562_16; + operand.values[17] = tokenCoding5562_17; + operand.values[19] = tokenCoding5562_19; +} +x64Token x64Parser::tokenBranches5561[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5562, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5558[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5559 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5561 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5565_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5565_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5565(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5565_16; + operand.values[17] = tokenCoding5565_17; +} +x64Token x64Parser::tokenBranches5564[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5565, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5563[] = { + {x64Token::TOKEN, 12, 0, 1, NULL, NULL, x64Parser::tokenBranches5564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5568(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 465; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5567[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc5568, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5570(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 466; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5572(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 467; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5569[] = { + {x64Token::NUMBER, 12, 1, 0, NULL,&x64Parser::TokenFunc5570, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5572, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5573(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 466; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5574(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 467; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5566[] = { + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches5567 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5569 }, + {x64Token::NUMBER, 11, 1, 0, NULL,&x64Parser::TokenFunc5573, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5574, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5579_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5579(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5579_16; + operand.values[17] = tokenCoding5579_17; + operand.values[18] = tokenCoding5579_18; + operand.values[19] = tokenCoding5579_19; +} +x64Token x64Parser::tokenBranches5578[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5579, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5577[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5578 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5576[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5577 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5583_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5583(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5583_16; + operand.values[17] = tokenCoding5583_17; + operand.values[18] = tokenCoding5583_18; + operand.values[19] = tokenCoding5583_19; +} +x64Token x64Parser::tokenBranches5582[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5583, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5581[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5582 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5580[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5581 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5587_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5587(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5587_16; + operand.values[17] = tokenCoding5587_17; + operand.values[18] = tokenCoding5587_18; + operand.values[19] = tokenCoding5587_19; +} +x64Token x64Parser::tokenBranches5586[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5587, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5585[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5586 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5584[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5585 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5576(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5580(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5584(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5575[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5576, x64Parser::tokenBranches5576 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5580, x64Parser::tokenBranches5580 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5584, x64Parser::tokenBranches5584 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5590_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5590(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5590_16; + operand.values[17] = tokenCoding5590_17; + operand.values[18] = tokenCoding5590_18; + operand.values[19] = tokenCoding5590_19; +} +x64Token x64Parser::tokenBranches5589[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5590, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5588[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5589 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5604_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5604(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5604_16; + operand.values[17] = tokenCoding5604_17; + operand.values[18] = tokenCoding5604_18; + operand.values[19] = tokenCoding5604_19; +} +x64Token x64Parser::tokenBranches5603[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5604, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5594_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5594(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5594_16; + operand.values[17] = tokenCoding5594_17; + operand.values[18] = tokenCoding5594_18; + operand.values[19] = tokenCoding5594_19; +} +x64Token x64Parser::tokenBranches5593[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5594, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5603 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5592[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5593 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5608_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5608(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5608_16; + operand.values[17] = tokenCoding5608_17; + operand.values[18] = tokenCoding5608_18; + operand.values[19] = tokenCoding5608_19; +} +x64Token x64Parser::tokenBranches5607[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5608, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5612_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5612(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5612_16; + operand.values[17] = tokenCoding5612_17; + operand.values[18] = tokenCoding5612_18; + operand.values[19] = tokenCoding5612_19; +} +x64Token x64Parser::tokenBranches5611[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5612, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5597_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5597(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5597_16; + operand.values[17] = tokenCoding5597_17; + operand.values[18] = tokenCoding5597_18; + operand.values[19] = tokenCoding5597_19; +} +Coding x64Parser::tokenCoding5600_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5600(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5600_16; + operand.values[17] = tokenCoding5600_17; + operand.values[18] = tokenCoding5600_18; + operand.values[19] = tokenCoding5600_19; +} +x64Token x64Parser::tokenBranches5596[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5597, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5600, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5607 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5611 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5595[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5596 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5625_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5625(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5625_16; + operand.values[17] = tokenCoding5625_17; + operand.values[18] = tokenCoding5625_18; + operand.values[19] = tokenCoding5625_19; +} +x64Token x64Parser::tokenBranches5624[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5625, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5629_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5629(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5629_16; + operand.values[17] = tokenCoding5629_17; + operand.values[18] = tokenCoding5629_18; + operand.values[19] = tokenCoding5629_19; +} +x64Token x64Parser::tokenBranches5628[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5629, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5633_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5633(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5633_16; + operand.values[17] = tokenCoding5633_17; + operand.values[18] = tokenCoding5633_18; + operand.values[19] = tokenCoding5633_19; +} +x64Token x64Parser::tokenBranches5632[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5633, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5615_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5615(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5615_16; + operand.values[17] = tokenCoding5615_17; + operand.values[18] = tokenCoding5615_18; + operand.values[19] = tokenCoding5615_19; +} +Coding x64Parser::tokenCoding5618_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5618(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5618_16; + operand.values[17] = tokenCoding5618_17; + operand.values[18] = tokenCoding5618_18; + operand.values[19] = tokenCoding5618_19; +} +Coding x64Parser::tokenCoding5621_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5621(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5621_16; + operand.values[17] = tokenCoding5621_17; + operand.values[18] = tokenCoding5621_18; + operand.values[19] = tokenCoding5621_19; +} +x64Token x64Parser::tokenBranches5614[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5615, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5618, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5621, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5624 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5628 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5632 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5613[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5614 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5592(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5595(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5613(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5591[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5592, x64Parser::tokenBranches5592 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5595, x64Parser::tokenBranches5595 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5613, x64Parser::tokenBranches5613 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5637_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5637_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5637_19[] = { + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5637(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5637_16; + operand.values[17] = tokenCoding5637_17; + operand.values[19] = tokenCoding5637_19; +} +Coding x64Parser::tokenCoding5640_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5640_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5640_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5640(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5640_16; + operand.values[17] = tokenCoding5640_17; + operand.values[19] = tokenCoding5640_19; +} +Coding x64Parser::tokenCoding5643_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5643_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5643_19[] = { + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5643(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5643_16; + operand.values[17] = tokenCoding5643_17; + operand.values[19] = tokenCoding5643_19; +} +x64Token x64Parser::tokenBranches5636[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5637, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5640, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5643, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5636 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5648_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5648_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5648_19[] = { + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5648(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5648_16; + operand.values[17] = tokenCoding5648_17; + operand.values[19] = tokenCoding5648_19; +} +Coding x64Parser::tokenCoding5653_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5653_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5653_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5653(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5653_16; + operand.values[17] = tokenCoding5653_17; + operand.values[19] = tokenCoding5653_19; +} +x64Token x64Parser::tokenBranches5647[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5648, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5653, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5657_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5657_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5657_19[] = { + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5657(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5657_16; + operand.values[17] = tokenCoding5657_17; + operand.values[19] = tokenCoding5657_19; +} +x64Token x64Parser::tokenBranches5646[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5647 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5657, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5646 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5644[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5645 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5660_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5660_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5660_19[] = { + { CODING_NAME("one") Coding::stateFunc, 4 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5660(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5660_16; + operand.values[17] = tokenCoding5660_17; + operand.values[19] = tokenCoding5660_19; +} +Coding x64Parser::tokenCoding5663_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5663_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5663_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5663(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5663_16; + operand.values[17] = tokenCoding5663_17; + operand.values[19] = tokenCoding5663_19; +} +Coding x64Parser::tokenCoding5666_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5666_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5666_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5666(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5666_16; + operand.values[17] = tokenCoding5666_17; + operand.values[19] = tokenCoding5666_19; +} +x64Token x64Parser::tokenBranches5659[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5660, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5663, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5666, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5658[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5659 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5671_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5671_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5671_19[] = { + { CODING_NAME("one") Coding::stateFunc, 4 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5671(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5671_16; + operand.values[17] = tokenCoding5671_17; + operand.values[19] = tokenCoding5671_19; +} +Coding x64Parser::tokenCoding5676_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5676_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5676_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5676(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5676_16; + operand.values[17] = tokenCoding5676_17; + operand.values[19] = tokenCoding5676_19; +} +x64Token x64Parser::tokenBranches5670[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5671, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5676, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5680_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5680_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5680_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5680(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5680_16; + operand.values[17] = tokenCoding5680_17; + operand.values[19] = tokenCoding5680_19; +} +x64Token x64Parser::tokenBranches5669[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5670 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5680, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5668[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5669 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5667[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5668 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5687_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5687_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5687_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5687(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5687_16; + operand.values[17] = tokenCoding5687_17; + operand.values[19] = tokenCoding5687_19; +} +x64Token x64Parser::tokenBranches5686[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5687, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5683_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5683_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5683_19[] = { + { CODING_NAME("one") Coding::stateFunc, 5 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5683(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5683_16; + operand.values[17] = tokenCoding5683_17; + operand.values[19] = tokenCoding5683_19; +} +Coding x64Parser::tokenCoding5690_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5690_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5690_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5690(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5690_16; + operand.values[17] = tokenCoding5690_17; + operand.values[19] = tokenCoding5690_19; +} +x64Token x64Parser::tokenBranches5682[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5683, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5686 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5690, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5682 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5695_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5695_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5695_19[] = { + { CODING_NAME("one") Coding::stateFunc, 5 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5695(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5695_16; + operand.values[17] = tokenCoding5695_17; + operand.values[19] = tokenCoding5695_19; +} +Coding x64Parser::tokenCoding5700_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5700_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5700_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5700(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5700_16; + operand.values[17] = tokenCoding5700_17; + operand.values[19] = tokenCoding5700_19; +} +x64Token x64Parser::tokenBranches5694[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5695, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5700, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5704_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5704_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5704_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5704(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5704_16; + operand.values[17] = tokenCoding5704_17; + operand.values[19] = tokenCoding5704_19; +} +x64Token x64Parser::tokenBranches5693[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5694 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5704, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5692[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5693 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5691[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5692 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5711_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5711_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5711_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5711(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5711_16; + operand.values[17] = tokenCoding5711_17; + operand.values[19] = tokenCoding5711_19; +} +x64Token x64Parser::tokenBranches5710[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5711, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5707_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5707_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5707_19[] = { + { CODING_NAME("one") Coding::stateFunc, 6 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5707(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5707_16; + operand.values[17] = tokenCoding5707_17; + operand.values[19] = tokenCoding5707_19; +} +Coding x64Parser::tokenCoding5714_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5714_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5714_19[] = { + { CODING_NAME("") Coding::stateFunc, 6 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5714(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5714_16; + operand.values[17] = tokenCoding5714_17; + operand.values[19] = tokenCoding5714_19; +} +x64Token x64Parser::tokenBranches5706[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5707, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5710 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5714, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5705[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5706 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5719_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5719_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5719_19[] = { + { CODING_NAME("one") Coding::stateFunc, 6 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5719(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5719_16; + operand.values[17] = tokenCoding5719_17; + operand.values[19] = tokenCoding5719_19; +} +Coding x64Parser::tokenCoding5724_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5724_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5724_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5724(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5724_16; + operand.values[17] = tokenCoding5724_17; + operand.values[19] = tokenCoding5724_19; +} +x64Token x64Parser::tokenBranches5718[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5719, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5724, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5728_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5728_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5728_19[] = { + { CODING_NAME("") Coding::stateFunc, 6 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5728(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5728_16; + operand.values[17] = tokenCoding5728_17; + operand.values[19] = tokenCoding5728_19; +} +x64Token x64Parser::tokenBranches5717[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5718 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5728, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5716[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5717 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5715[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5716 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5634[] = { + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5635 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5644 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5658 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5667 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5681 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5691 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5705 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5715 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5735_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5735(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5735_16; + operand.values[17] = tokenCoding5735_17; + operand.values[18] = tokenCoding5735_18; + operand.values[19] = tokenCoding5735_19; +} +Coding x64Parser::tokenCoding5741_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5741(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5741_16; + operand.values[17] = tokenCoding5741_17; + operand.values[18] = tokenCoding5741_18; + operand.values[19] = tokenCoding5741_19; +} +x64Token x64Parser::tokenBranches5734[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5735, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5741, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5733[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5734 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5733(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5732[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5733, x64Parser::tokenBranches5733 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5731[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5732 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5730[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5731 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5747_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5747(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5747_16; + operand.values[17] = tokenCoding5747_17; + operand.values[18] = tokenCoding5747_18; + operand.values[19] = tokenCoding5747_19; +} +Coding x64Parser::tokenCoding5753_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5753(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5753_16; + operand.values[17] = tokenCoding5753_17; + operand.values[18] = tokenCoding5753_18; + operand.values[19] = tokenCoding5753_19; +} +x64Token x64Parser::tokenBranches5746[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5747, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5753, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5745[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5746 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5745(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5744[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5745, x64Parser::tokenBranches5745 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5743[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5744 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5742[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5743 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5759_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5759(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5759_16; + operand.values[17] = tokenCoding5759_17; + operand.values[18] = tokenCoding5759_18; + operand.values[19] = tokenCoding5759_19; +} +Coding x64Parser::tokenCoding5765_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5765(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5765_16; + operand.values[17] = tokenCoding5765_17; + operand.values[18] = tokenCoding5765_18; + operand.values[19] = tokenCoding5765_19; +} +x64Token x64Parser::tokenBranches5758[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5759, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5765, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5757[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5758 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5757(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5756[] = { + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5757, x64Parser::tokenBranches5757 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5755[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5756 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5754[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5755 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5729[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5730 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5742 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5754 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5767_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5767_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5767(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5767_16; + operand.values[17] = tokenCoding5767_17; +} +x64Token x64Parser::tokenBranches5766[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5767, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5771_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5771_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5771_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5771(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5771_16; + operand.values[17] = tokenCoding5771_17; + operand.values[18] = tokenCoding5771_18; +} +x64Token x64Parser::tokenBranches5770[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5771, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5769[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5770 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5769(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5768[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5769, x64Parser::tokenBranches5769 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5775_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5775(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5775_16; + operand.values[17] = tokenCoding5775_17; + operand.values[18] = tokenCoding5775_18; + operand.values[19] = tokenCoding5775_19; +} +x64Token x64Parser::tokenBranches5774[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5775, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5773[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5774 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5778_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5778(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5778_16; + operand.values[17] = tokenCoding5778_17; + operand.values[18] = tokenCoding5778_18; + operand.values[19] = tokenCoding5778_19; +} +x64Token x64Parser::tokenBranches5777[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5778, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5776[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5777 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5773(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5772[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5773, x64Parser::tokenBranches5773 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5776 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5782_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5782(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5782_16; + operand.values[17] = tokenCoding5782_17; + operand.values[18] = tokenCoding5782_18; + operand.values[19] = tokenCoding5782_19; +} +x64Token x64Parser::tokenBranches5781[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5782, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5780[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5781 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5785_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5785(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5785_16; + operand.values[17] = tokenCoding5785_17; + operand.values[18] = tokenCoding5785_18; + operand.values[19] = tokenCoding5785_19; +} +x64Token x64Parser::tokenBranches5784[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5785, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5783[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5784 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5780(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5779[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5780, x64Parser::tokenBranches5780 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5783 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5789_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5789(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5789_16; + operand.values[17] = tokenCoding5789_17; + operand.values[18] = tokenCoding5789_18; + operand.values[19] = tokenCoding5789_19; +} +x64Token x64Parser::tokenBranches5788[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5789, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5787[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5788 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5792_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5792(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5792_16; + operand.values[17] = tokenCoding5792_17; + operand.values[18] = tokenCoding5792_18; + operand.values[19] = tokenCoding5792_19; +} +x64Token x64Parser::tokenBranches5791[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5792, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5790[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5791 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5787(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5786[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5787, x64Parser::tokenBranches5787 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5790 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5796_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5796_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5796_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5796(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5796_16; + operand.values[17] = tokenCoding5796_17; + operand.values[18] = tokenCoding5796_18; +} +x64Token x64Parser::tokenBranches5795[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5796, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5794[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5795 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5794(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5793[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5794, x64Parser::tokenBranches5794 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5800_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5800_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5800_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5800(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5800_16; + operand.values[17] = tokenCoding5800_17; + operand.values[18] = tokenCoding5800_18; +} +x64Token x64Parser::tokenBranches5799[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5800, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5798[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5799 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5798(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5797[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5798, x64Parser::tokenBranches5798 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5804_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5804_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5804_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5804(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5804_16; + operand.values[17] = tokenCoding5804_17; + operand.values[18] = tokenCoding5804_18; +} +x64Token x64Parser::tokenBranches5803[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc5804, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5802[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5803 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5807_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5807_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5807_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5807(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5807_16; + operand.values[17] = tokenCoding5807_17; + operand.values[18] = tokenCoding5807_18; +} +x64Token x64Parser::tokenBranches5806[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc5807, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5805[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5806 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5802(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5805(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5801[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5802, x64Parser::tokenBranches5802 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5805, x64Parser::tokenBranches5805 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5812_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5812_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5812_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5812(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5812_16; + operand.values[17] = tokenCoding5812_17; + operand.values[18] = tokenCoding5812_18; +} +x64Token x64Parser::tokenBranches5811[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5812, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5816_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5816_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5816_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5816(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5816_16; + operand.values[17] = tokenCoding5816_17; + operand.values[18] = tokenCoding5816_18; +} +x64Token x64Parser::tokenBranches5815[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5816, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5810[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5811 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5815 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5809[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5810 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5809(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5808[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5809, x64Parser::tokenBranches5809 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5820_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5820(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5820_16; + operand.values[17] = tokenCoding5820_17; + operand.values[23] = tokenCoding5820_23; + operand.values[18] = tokenCoding5820_18; +} +x64Token x64Parser::tokenBranches5819[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5820, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5818[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5819 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5823_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5823(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5823_16; + operand.values[17] = tokenCoding5823_17; + operand.values[23] = tokenCoding5823_23; + operand.values[18] = tokenCoding5823_18; +} +x64Token x64Parser::tokenBranches5822[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5823, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5821[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5822 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5818(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5821(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5817[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5818, x64Parser::tokenBranches5818 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5821, x64Parser::tokenBranches5821 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5829_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5829_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5829_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5829(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5829_16; + operand.values[17] = tokenCoding5829_17; + operand.values[18] = tokenCoding5829_18; +} +x64Token x64Parser::tokenBranches5828[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5829, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5827[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5828 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5826[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5827 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5825[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5826 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5825(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5824[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5825, x64Parser::tokenBranches5825 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5833_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5833(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5833_16; + operand.values[17] = tokenCoding5833_17; + operand.values[23] = tokenCoding5833_23; + operand.values[18] = tokenCoding5833_18; + operand.values[19] = tokenCoding5833_19; +} +x64Token x64Parser::tokenBranches5832[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5833, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5831[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5832 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5836_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5836(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5836_16; + operand.values[17] = tokenCoding5836_17; + operand.values[23] = tokenCoding5836_23; + operand.values[18] = tokenCoding5836_18; + operand.values[19] = tokenCoding5836_19; +} +x64Token x64Parser::tokenBranches5835[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5836, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5834[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5835 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5839_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5839(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5839_16; + operand.values[17] = tokenCoding5839_17; + operand.values[23] = tokenCoding5839_23; + operand.values[18] = tokenCoding5839_18; + operand.values[19] = tokenCoding5839_19; +} +x64Token x64Parser::tokenBranches5838[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5839, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5837[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5838 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5842_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5842(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5842_16; + operand.values[17] = tokenCoding5842_17; + operand.values[23] = tokenCoding5842_23; + operand.values[18] = tokenCoding5842_18; + operand.values[19] = tokenCoding5842_19; +} +x64Token x64Parser::tokenBranches5841[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5842, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5840[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5841 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5837(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5840(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5830[] = { + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches5831 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches5834 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5837, x64Parser::tokenBranches5837 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5840, x64Parser::tokenBranches5840 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5848_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5848_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5848_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5848(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5848_16; + operand.values[17] = tokenCoding5848_17; + operand.values[18] = tokenCoding5848_18; +} +x64Token x64Parser::tokenBranches5847[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5848, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5846[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5847 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5845[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5846 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5844[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5845 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5844(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5843[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5844, x64Parser::tokenBranches5844 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5854_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5854_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5854_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5854(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5854_16; + operand.values[17] = tokenCoding5854_17; + operand.values[18] = tokenCoding5854_18; +} +x64Token x64Parser::tokenBranches5853[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5854, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5852[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5853 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5851[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5852 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5850[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5851 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5850(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5849[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5850, x64Parser::tokenBranches5850 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5865_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5865(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5865_16; + operand.values[17] = tokenCoding5865_17; + operand.values[18] = tokenCoding5865_18; + operand.values[19] = tokenCoding5865_19; +} +x64Token x64Parser::tokenBranches5864[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5865, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5863[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5864 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5862[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5863 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5870_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5870_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5870_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5870(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 469; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5870_16; + operand.values[17] = tokenCoding5870_17; + operand.values[18] = tokenCoding5870_18; +} +Coding x64Parser::tokenCoding5871_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5871_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5871_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5871(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 470; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5871_16; + operand.values[17] = tokenCoding5871_17; + operand.values[18] = tokenCoding5871_18; +} +x64Token x64Parser::tokenBranches5869[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5870, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5871, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5880(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 471; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5879[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc5880, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5884(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 472; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5883[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc5884, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5878[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5879 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5883 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5877[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5878 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5892_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5892(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5892_16; + operand.values[17] = tokenCoding5892_17; + operand.values[18] = tokenCoding5892_18; + operand.values[19] = tokenCoding5892_19; +} +x64Token x64Parser::tokenBranches5891[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5892, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5894_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5894(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5894_16; + operand.values[17] = tokenCoding5894_17; + operand.values[18] = tokenCoding5894_18; + operand.values[19] = tokenCoding5894_19; +} +x64Token x64Parser::tokenBranches5893[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5894, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5896_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5896(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5896_16; + operand.values[17] = tokenCoding5896_17; + operand.values[18] = tokenCoding5896_18; + operand.values[19] = tokenCoding5896_19; +} +x64Token x64Parser::tokenBranches5895[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5896, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5905_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5905(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5905_16; + operand.values[17] = tokenCoding5905_17; + operand.values[18] = tokenCoding5905_18; + operand.values[19] = tokenCoding5905_19; +} +x64Token x64Parser::tokenBranches5904[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5905, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5908_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5908(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5908_16; + operand.values[17] = tokenCoding5908_17; + operand.values[18] = tokenCoding5908_18; + operand.values[19] = tokenCoding5908_19; +} +x64Token x64Parser::tokenBranches5907[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5908, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5898(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 475; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5900(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 476; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding5902_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5902(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5902_16; + operand.values[17] = tokenCoding5902_17; + operand.values[18] = tokenCoding5902_18; + operand.values[19] = tokenCoding5902_19; +} +x64Token x64Parser::tokenBranches5897[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc5898, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc5900, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5902, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5904 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5907 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5877(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::number; + operand.values[2]->val = operands.size(); + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5885(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 473; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5886(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 474; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding5887_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5887(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5887_16; + operand.values[17] = tokenCoding5887_17; + operand.values[18] = tokenCoding5887_18; + operand.values[19] = tokenCoding5887_19; +} +Coding x64Parser::tokenCoding5888_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5888(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5888_16; + operand.values[17] = tokenCoding5888_17; + operand.values[18] = tokenCoding5888_18; + operand.values[19] = tokenCoding5888_19; +} +Coding x64Parser::tokenCoding5889_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5889(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5889_16; + operand.values[17] = tokenCoding5889_17; + operand.values[18] = tokenCoding5889_18; + operand.values[19] = tokenCoding5889_19; +} +Coding x64Parser::tokenCoding5890_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5890(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5890_16; + operand.values[17] = tokenCoding5890_17; + operand.values[18] = tokenCoding5890_18; + operand.values[19] = tokenCoding5890_19; +} +x64Token x64Parser::tokenBranches5876[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc5877, x64Parser::tokenBranches5877 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc5885, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5886, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5887, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5888, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5889, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5890, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5891 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5893 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5895 }, + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches5897 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5912(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 477; +} +x64Token x64Parser::tokenBranches5911[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5912, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5962(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 478; +} +x64Token x64Parser::tokenBranches5961[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5962, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5960[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5961 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5959[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5960 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5958[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5959 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5957[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5958 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5956[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5957 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5955[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5956 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5954[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5955 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5988(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 480; +} +x64Token x64Parser::tokenBranches5987[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5988, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5986[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches5987 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5985[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5986 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5984[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5985 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5983[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5984 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5982[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5983 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5981[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5982 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5980[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5981 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5953[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5954 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5980 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5952[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5953 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5975(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 479; +} +x64Token x64Parser::tokenBranches5974[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5975, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5973[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5974 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5972[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5973 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5971[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5972 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5970[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5971 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5969[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5970 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5968[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5969 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5967[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5968 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6001(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 481; +} +x64Token x64Parser::tokenBranches6000[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6001, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5999[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6000 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5998[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5999 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5997[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5998 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5996[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5997 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5995[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5996 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5994[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5995 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5993[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5994 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6023(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 483; +} +x64Token x64Parser::tokenBranches6022[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6023, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6021[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6022 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6020[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6021 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6019[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6020 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6018[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6019 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6017[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6018 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6016[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6017 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6015[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6016 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5966[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5967 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5993 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6015 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5965[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5966 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6010(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 482; +} +x64Token x64Parser::tokenBranches6009[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6010, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6008[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6009 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6007[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6008 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6006[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6007 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6005[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6006 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6004[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6005 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5965(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5951[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches5952 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc5965, x64Parser::tokenBranches5965 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6004 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5950[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5951 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6036(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 484; +} +x64Token x64Parser::tokenBranches6035[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6036, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6034[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6035 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6033[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6034 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6032[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6033 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6031[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6032 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6030[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6031 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6029[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6030 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6028[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6029 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6062(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 486; +} +x64Token x64Parser::tokenBranches6061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6062, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6060[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6061 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6059[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6060 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6058[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6059 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6057[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6058 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6056[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6057 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6055[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6056 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6054[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6055 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6027[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6028 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6054 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6026[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6027 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6049(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 485; +} +x64Token x64Parser::tokenBranches6048[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6049, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6047[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6048 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6046[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6047 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6045[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6046 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6044[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6045 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6043[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6044 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6042[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6043 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6041[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6042 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6075(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 487; +} +x64Token x64Parser::tokenBranches6074[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6075, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6073[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6074 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6072[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6073 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6071[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6072 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6070[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6071 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6069[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6070 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6068[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6069 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6067[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6068 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6095(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 489; +} +x64Token x64Parser::tokenBranches6094[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6095, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6093[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6094 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6092[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6093 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6091[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6092 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6090[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6091 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6089[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6090 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6040[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6041 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6067 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6089 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6039[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6040 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6084(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 488; +} +x64Token x64Parser::tokenBranches6083[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6084, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6082[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6083 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6081[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6082 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6080[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6081 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6079[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6080 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6078[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6079 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6039(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6025[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6026 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6039, x64Parser::tokenBranches6039 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6078 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6024[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6025 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6108(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 490; +} +x64Token x64Parser::tokenBranches6107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6108, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6107 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6105[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6106 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6104[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6105 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6103[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6104 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6102[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6103 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6101[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6102 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6100[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6101 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6134(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 492; +} +x64Token x64Parser::tokenBranches6133[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6134, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6132[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6133 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6131[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6132 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6130[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6131 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6129[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6130 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6128[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6129 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6127[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6128 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6126[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6127 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6099[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6100 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6126 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6098[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6099 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6121(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 491; +} +x64Token x64Parser::tokenBranches6120[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6121, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6119[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6120 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6118[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6119 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6117[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6118 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6116[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6117 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6115[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6116 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6114[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6115 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6113[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6114 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6147(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 493; +} +x64Token x64Parser::tokenBranches6146[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6147, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6145[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6146 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6144[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6145 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6143[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6144 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6142[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6143 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6141[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6142 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6140[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6141 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6139[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6140 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6167(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 495; +} +x64Token x64Parser::tokenBranches6166[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6167, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6165[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6166 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6164[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6165 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6163[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6164 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6162[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6163 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6161[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6162 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6112[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6113 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6139 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6161 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6111[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6112 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6156(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 494; +} +x64Token x64Parser::tokenBranches6155[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6156, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6154[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6155 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6153[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6154 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6152[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6153 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6151[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6152 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6150[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6151 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6111(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6097[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6098 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6111, x64Parser::tokenBranches6111 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6150 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6096[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6097 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6180(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 496; +} +x64Token x64Parser::tokenBranches6179[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6180, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6178[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6179 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6177[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6176[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6177 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6175[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6176 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6174[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6175 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6173[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6174 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6172[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6173 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6171[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6172 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6170[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6171 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6193(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 497; +} +x64Token x64Parser::tokenBranches6192[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6193, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6191[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6192 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6190[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6191 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6189[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6190 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6188[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6189 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6187[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6188 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6186[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6187 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6185[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6186 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6213(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 499; +} +x64Token x64Parser::tokenBranches6212[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6213, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6211[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6212 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6210[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6211 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6209[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6210 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6208[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6209 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6207[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6208 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6184[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6185 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6207 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6183[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6184 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6202(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 498; +} +x64Token x64Parser::tokenBranches6201[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6202, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6200[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6201 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6199[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6200 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6198[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6199 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6197 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6183(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6169[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6170 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6183, x64Parser::tokenBranches6183 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6196 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6168[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6169 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5949[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5950 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6024 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6096 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6168 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6218(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 500; +} +x64Token x64Parser::tokenBranches6217[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6218, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6223_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6223(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6223_16; + operand.values[17] = tokenCoding6223_17; + operand.values[18] = tokenCoding6223_18; + operand.values[19] = tokenCoding6223_19; +} +Coding x64Parser::tokenCoding6227_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6227(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6227_16; + operand.values[17] = tokenCoding6227_17; + operand.values[23] = tokenCoding6227_23; + operand.values[18] = tokenCoding6227_18; + operand.values[19] = tokenCoding6227_19; +} +x64Token x64Parser::tokenBranches6222[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6223, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc6227, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6221[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6222 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6220[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6221 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6231_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6231(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6231_16; + operand.values[17] = tokenCoding6231_17; + operand.values[18] = tokenCoding6231_18; + operand.values[19] = tokenCoding6231_19; +} +x64Token x64Parser::tokenBranches6230[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6231, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6230 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6228[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6229 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6235_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6235(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6235_16; + operand.values[17] = tokenCoding6235_17; + operand.values[18] = tokenCoding6235_18; + operand.values[19] = tokenCoding6235_19; +} +x64Token x64Parser::tokenBranches6234[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6235, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6233[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6234 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6232[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches6233 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6239_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6239(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6239_16; + operand.values[17] = tokenCoding6239_17; + operand.values[18] = tokenCoding6239_18; + operand.values[19] = tokenCoding6239_19; +} +x64Token x64Parser::tokenBranches6238[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc6239, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6238 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6236[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6237 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6219[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6220 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6228 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6232 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6236 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6241_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6241(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6241_16; + operand.values[17] = tokenCoding6241_17; + operand.values[18] = tokenCoding6241_18; + operand.values[19] = tokenCoding6241_19; +} +x64Token x64Parser::tokenBranches6240[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6241, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6243_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6243(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6243_16; + operand.values[17] = tokenCoding6243_17; + operand.values[18] = tokenCoding6243_18; + operand.values[19] = tokenCoding6243_19; +} +x64Token x64Parser::tokenBranches6242[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6243, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6246(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 501; +} +x64Token x64Parser::tokenBranches6245[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 502; + operand.values[27] = new Coding[2]; + CleanupValues.push_back(operand.values[27]); + operand.values[27]->type = Coding::number; + operand.values[27]->val = operands.size(); + operand.values[27]->bits = 0; + operand.values[27]->field = 0; + operand.values[27]->unary = 0; + operand.values[27]->binary = 0; + operand.values[27][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6257[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6258, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6256[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6255[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6254[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6255, x64Parser::tokenBranches6255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6253[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6262_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&' }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6262(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6262_16; + operand.values[17] = tokenCoding6262_17; + operand.values[18] = tokenCoding6262_18; + operand.values[19] = tokenCoding6262_19; +} +x64Token x64Parser::tokenBranches6261[] = { + {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6262, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6260[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6259[] = { + {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6260, x64Parser::tokenBranches6260 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6274[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6275, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6273[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6272[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6278[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6279, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6277[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6276[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6282[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6283, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6281[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6280[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6286[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6287, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6285[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6284[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6290[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6291, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6289[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6288[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6294[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6295, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6293[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6292[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6298[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6299, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6296[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6302[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6303, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6301[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6300[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6306[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6307, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6310_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6310_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6310_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6310(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6310_16; + operand.values[17] = tokenCoding6310_17; + operand.values[19] = tokenCoding6310_19; +} +x64Token x64Parser::tokenBranches6309[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6310, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6312_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6312_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6312_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6312(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6312_16; + operand.values[17] = tokenCoding6312_17; + operand.values[19] = tokenCoding6312_19; +} +x64Token x64Parser::tokenBranches6311[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6312, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6304[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6308, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6315[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6316, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6313[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6319[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6320, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6318[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6317[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6324_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6324_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6324_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6324(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6324_16; + operand.values[17] = tokenCoding6324_17; + operand.values[19] = tokenCoding6324_19; +} +x64Token x64Parser::tokenBranches6323[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6324, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6326_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6326_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6326_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6326_16; + operand.values[17] = tokenCoding6326_17; + operand.values[19] = tokenCoding6326_19; +} +x64Token x64Parser::tokenBranches6325[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6326, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6321[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6337_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6337_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6337(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6337_18; + operand.values[19] = tokenCoding6337_19; +} +x64Token x64Parser::tokenBranches6336[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6337, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6339_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6339_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6339(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6339_18; + operand.values[19] = tokenCoding6339_19; +} +x64Token x64Parser::tokenBranches6338[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6339, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6347_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6347(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6347_16; + operand.values[17] = tokenCoding6347_17; + operand.values[18] = tokenCoding6347_18; + operand.values[19] = tokenCoding6347_19; +} +x64Token x64Parser::tokenBranches6346[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6347, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6349_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6349(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6349_16; + operand.values[17] = tokenCoding6349_17; + operand.values[18] = tokenCoding6349_18; + operand.values[19] = tokenCoding6349_19; +} +x64Token x64Parser::tokenBranches6348[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6349, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6351_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6351(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6351_16; + operand.values[17] = tokenCoding6351_17; + operand.values[18] = tokenCoding6351_18; + operand.values[19] = tokenCoding6351_19; +} +x64Token x64Parser::tokenBranches6350[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6351, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6345[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6359_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6359(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6359_16; + operand.values[17] = tokenCoding6359_17; + operand.values[18] = tokenCoding6359_18; + operand.values[19] = tokenCoding6359_19; +} +x64Token x64Parser::tokenBranches6358[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6359, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6361_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6361(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6361_16; + operand.values[17] = tokenCoding6361_17; + operand.values[18] = tokenCoding6361_18; + operand.values[19] = tokenCoding6361_19; +} +x64Token x64Parser::tokenBranches6360[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6361, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6357[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6367_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6367_16; + operand.values[17] = tokenCoding6367_17; + operand.values[18] = tokenCoding6367_18; + operand.values[19] = tokenCoding6367_19; +} +x64Token x64Parser::tokenBranches6366[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6369_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6369(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6369_16; + operand.values[17] = tokenCoding6369_17; + operand.values[18] = tokenCoding6369_18; + operand.values[19] = tokenCoding6369_19; +} +x64Token x64Parser::tokenBranches6368[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6369, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6371_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6371_16; + operand.values[17] = tokenCoding6371_17; + operand.values[18] = tokenCoding6371_18; + operand.values[19] = tokenCoding6371_19; +} +x64Token x64Parser::tokenBranches6370[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6371, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6365_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6365_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6365_18; + operand.values[19] = tokenCoding6365_19; +} +x64Token x64Parser::tokenBranches6364[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6365, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6375_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6375_16; + operand.values[17] = tokenCoding6375_17; + operand.values[18] = tokenCoding6375_18; + operand.values[19] = tokenCoding6375_19; +} +x64Token x64Parser::tokenBranches6374[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6373[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6377_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6377_16; + operand.values[17] = tokenCoding6377_17; + operand.values[18] = tokenCoding6377_18; + operand.values[19] = tokenCoding6377_19; +} +x64Token x64Parser::tokenBranches6376[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6388_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6388(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6388_16; + operand.values[17] = tokenCoding6388_17; + operand.values[18] = tokenCoding6388_18; + operand.values[19] = tokenCoding6388_19; +} +x64Token x64Parser::tokenBranches6387[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6388, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6395_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5300_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6395(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6395_16; + operand.values[17] = tokenCoding6395_17; + operand.values[18] = tokenCoding6395_18; + operand.values[19] = tokenCoding6395_19; +} +x64Token x64Parser::tokenBranches6394[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6395, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5300_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5300(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5300_16; - operand.values[17] = tokenCoding5300_17; - operand.values[18] = tokenCoding5300_18; - operand.values[19] = tokenCoding5300_19; -} -x64Token x64Parser::tokenBranches5299[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5300, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5298[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5299}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5297[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5298}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5304_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5304(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5304_16; - operand.values[17] = tokenCoding5304_17; - operand.values[18] = tokenCoding5304_18; - operand.values[19] = tokenCoding5304_19; -} -x64Token x64Parser::tokenBranches5303[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5304, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5302[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5303}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5301[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5302}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5308_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5308_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6397(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6397_16; + operand.values[17] = tokenCoding6397_17; + operand.values[18] = tokenCoding6397_18; + operand.values[19] = tokenCoding6397_19; +} +x64Token x64Parser::tokenBranches6396[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6397, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5308_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6406_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5308_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5308(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5308_16; - operand.values[17] = tokenCoding5308_17; - operand.values[18] = tokenCoding5308_18; - operand.values[19] = tokenCoding5308_19; -} -x64Token x64Parser::tokenBranches5307[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5308, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5306[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5307}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5305[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5306}, {x64Token::EOT}}; -void x64Parser::TokenFunc5297(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5301(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5305(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding6406_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6406_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6406_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6406(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6406_16; + operand.values[17] = tokenCoding6406_17; + operand.values[18] = tokenCoding6406_18; + operand.values[19] = tokenCoding6406_19; } -x64Token x64Parser::tokenBranches5296[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5297, x64Parser::tokenBranches5297}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5301, x64Parser::tokenBranches5301}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5305, x64Parser::tokenBranches5305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5313(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 445; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5312[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5313, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5311[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5312}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5310[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5311}, {x64Token::EOT}}; -void x64Parser::TokenFunc5317(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 446; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5316[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5317, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5315[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5316}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5315}, {x64Token::EOT}}; -void x64Parser::TokenFunc5321(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 447; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5320[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5321, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5319[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5320}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5318[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5319}, {x64Token::EOT}}; -void x64Parser::TokenFunc5325(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 448; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5324[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5325, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5323[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5324}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5322[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5323}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5329_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6405[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6406, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5329_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5329_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5329_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5329(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5329_16; - operand.values[17] = tokenCoding5329_17; - operand.values[18] = tokenCoding5329_18; - operand.values[19] = tokenCoding5329_19; -} -x64Token x64Parser::tokenBranches5328[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5329, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5327[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5328}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5326[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5327}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5333_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6408(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6408_16; + operand.values[17] = tokenCoding6408_17; + operand.values[18] = tokenCoding6408_18; + operand.values[19] = tokenCoding6408_19; +} +x64Token x64Parser::tokenBranches6407[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6408, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5333_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6404_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5333(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5333_16; - operand.values[17] = tokenCoding5333_17; - operand.values[23] = tokenCoding5333_23; - operand.values[18] = tokenCoding5333_18; - operand.values[19] = tokenCoding5333_19; -} -x64Token x64Parser::tokenBranches5332[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5333, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5331[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5332}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5330[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5331}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5337_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6404_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5337_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6404(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6404_18; + operand.values[19] = tokenCoding6404_19; +} +x64Token x64Parser::tokenBranches6403[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6404, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5337_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5337_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5337(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5337_16; - operand.values[17] = tokenCoding5337_17; - operand.values[18] = tokenCoding5337_18; - operand.values[19] = tokenCoding5337_19; -} -x64Token x64Parser::tokenBranches5336[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5337, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5335[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5336}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5334[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5335}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5341_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5341(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5341_16; - operand.values[17] = tokenCoding5341_17; - operand.values[18] = tokenCoding5341_18; - operand.values[19] = tokenCoding5341_19; -} -x64Token x64Parser::tokenBranches5340[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5341, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5339[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5340}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5338[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5339}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5345_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6411(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6411_16; + operand.values[17] = tokenCoding6411_17; + operand.values[18] = tokenCoding6411_18; + operand.values[19] = tokenCoding6411_19; +} +x64Token x64Parser::tokenBranches6410[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6411, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5345_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6409[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5345_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5345_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5345(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5345_16; - operand.values[17] = tokenCoding5345_17; - operand.values[18] = tokenCoding5345_18; - operand.values[19] = tokenCoding5345_19; -} -x64Token x64Parser::tokenBranches5344[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5345, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5343[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5344}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5342[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5343}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5349_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5349(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5349_16; - operand.values[17] = tokenCoding5349_17; - operand.values[18] = tokenCoding5349_18; - operand.values[19] = tokenCoding5349_19; +void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6414_16; + operand.values[17] = tokenCoding6414_17; + operand.values[18] = tokenCoding6414_18; + operand.values[19] = tokenCoding6414_19; } -Coding x64Parser::tokenCoding5353_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6413[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6414, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5353_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6412[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5353_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5353_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5353_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5353(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5353_16; - operand.values[17] = tokenCoding5353_17; - operand.values[23] = tokenCoding5353_23; - operand.values[18] = tokenCoding5353_18; - operand.values[19] = tokenCoding5353_19; -} -x64Token x64Parser::tokenBranches5348[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5349, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5353, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5347[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5348}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5346[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5347}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5357_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5357_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5357_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6416(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6416_16; + operand.values[17] = tokenCoding6416_17; + operand.values[18] = tokenCoding6416_18; + operand.values[19] = tokenCoding6416_19; +} +x64Token x64Parser::tokenBranches6415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6416, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5357_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5357(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5357_16; - operand.values[17] = tokenCoding5357_17; - operand.values[18] = tokenCoding5357_18; - operand.values[19] = tokenCoding5357_19; -} -x64Token x64Parser::tokenBranches5356[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5357, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5355[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5356}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5354[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5355}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5361_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5361(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5361_16; - operand.values[17] = tokenCoding5361_17; - operand.values[18] = tokenCoding5361_18; - operand.values[19] = tokenCoding5361_19; -} -x64Token x64Parser::tokenBranches5360[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5361, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5359[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5360}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5358[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5359}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5365_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5365_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6418(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6418_16; + operand.values[17] = tokenCoding6418_17; + operand.values[18] = tokenCoding6418_18; + operand.values[19] = tokenCoding6418_19; +} +x64Token x64Parser::tokenBranches6417[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6418, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5365_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5365_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5365(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5365_16; - operand.values[17] = tokenCoding5365_17; - operand.values[18] = tokenCoding5365_18; - operand.values[19] = tokenCoding5365_19; -} -x64Token x64Parser::tokenBranches5364[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5365, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5363[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5364}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5362[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5363}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5370_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5370_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5370_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5370(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5370_16; - operand.values[17] = tokenCoding5370_17; - operand.values[19] = tokenCoding5370_19; -} -x64Token x64Parser::tokenBranches5369[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5370, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5368[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5369}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5367[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5368}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5366[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5367}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5375_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6422_16; + operand.values[17] = tokenCoding6422_17; + operand.values[18] = tokenCoding6422_18; + operand.values[19] = tokenCoding6422_19; +} +x64Token x64Parser::tokenBranches6421[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6422, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6424_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6424_16; + operand.values[17] = tokenCoding6424_17; + operand.values[18] = tokenCoding6424_18; + operand.values[19] = tokenCoding6424_19; +} +x64Token x64Parser::tokenBranches6423[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6424, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6426_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6426_16; + operand.values[17] = tokenCoding6426_17; + operand.values[18] = tokenCoding6426_18; + operand.values[19] = tokenCoding6426_19; +} +x64Token x64Parser::tokenBranches6425[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6426, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6420_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6420_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6420_18; + operand.values[19] = tokenCoding6420_19; +} +x64Token x64Parser::tokenBranches6419[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6420, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6429_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6429(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6429_16; + operand.values[17] = tokenCoding6429_17; + operand.values[18] = tokenCoding6429_18; + operand.values[19] = tokenCoding6429_19; +} +x64Token x64Parser::tokenBranches6428[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 503; +} +x64Token x64Parser::tokenBranches6427[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6433_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6433(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6433_16; + operand.values[17] = tokenCoding6433_17; + operand.values[18] = tokenCoding6433_18; + operand.values[19] = tokenCoding6433_19; +} +x64Token x64Parser::tokenBranches6432[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6433, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6434(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 504; +} +x64Token x64Parser::tokenBranches6431[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6434, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6443[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6444, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6442[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6441[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6447[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6448, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6446[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6445[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6456[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6457, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6455[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6454[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6460[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6461, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6459[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6458[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6463_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6463_16; + operand.values[17] = tokenCoding6463_17; + operand.values[18] = tokenCoding6463_18; + operand.values[19] = tokenCoding6463_19; +} +x64Token x64Parser::tokenBranches6462[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6463, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6465_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6465(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6465_16; + operand.values[17] = tokenCoding6465_17; + operand.values[18] = tokenCoding6465_18; + operand.values[19] = tokenCoding6465_19; +} +x64Token x64Parser::tokenBranches6464[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6465, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 505; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6475[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6476, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6503_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 4 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6503_16; + operand.values[17] = tokenCoding6503_17; + operand.values[18] = tokenCoding6503_18; + operand.values[19] = tokenCoding6503_19; +} +x64Token x64Parser::tokenBranches6502[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6503, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6509_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6509_16; + operand.values[17] = tokenCoding6509_17; + operand.values[18] = tokenCoding6509_18; + operand.values[19] = tokenCoding6509_19; +} +x64Token x64Parser::tokenBranches6501[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502 }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6509, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6500[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 506; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6500_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6500(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6500_16; + operand.values[17] = tokenCoding6500_17; + operand.values[18] = tokenCoding6500_18; + operand.values[19] = tokenCoding6500_19; +} +x64Token x64Parser::tokenBranches6479[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6480, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6500, x64Parser::tokenBranches6500 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6474[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6473[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 507; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6483[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6484, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6520_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 5 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6520_16; + operand.values[17] = tokenCoding6520_17; + operand.values[18] = tokenCoding6520_18; + operand.values[19] = tokenCoding6520_19; +} +x64Token x64Parser::tokenBranches6519[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6520, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6526_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6526_16; + operand.values[17] = tokenCoding6526_17; + operand.values[18] = tokenCoding6526_18; + operand.values[19] = tokenCoding6526_19; +} +x64Token x64Parser::tokenBranches6518[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6526, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6517[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 508; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6517_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6517(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6517_16; + operand.values[17] = tokenCoding6517_17; + operand.values[18] = tokenCoding6517_18; + operand.values[19] = tokenCoding6517_19; +} +x64Token x64Parser::tokenBranches6487[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6488, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6517, x64Parser::tokenBranches6517 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6482[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6481[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 509; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6491[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6492, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6537_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 6 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6537_16; + operand.values[17] = tokenCoding6537_17; + operand.values[18] = tokenCoding6537_18; + operand.values[19] = tokenCoding6537_19; +} +x64Token x64Parser::tokenBranches6536[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6537, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6543_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6543_16; + operand.values[17] = tokenCoding6543_17; + operand.values[18] = tokenCoding6543_18; + operand.values[19] = tokenCoding6543_19; +} +x64Token x64Parser::tokenBranches6535[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6543, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6534[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 510; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6534_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5375_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5375_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5375(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5375_16; - operand.values[17] = tokenCoding5375_17; - operand.values[19] = tokenCoding5375_19; -} -x64Token x64Parser::tokenBranches5374[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5375, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5380_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5380_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5380_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5380(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5380_16; - operand.values[17] = tokenCoding5380_17; - operand.values[19] = tokenCoding5380_19; +void x64Parser::TokenFunc6534(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6534_16; + operand.values[17] = tokenCoding6534_17; + operand.values[18] = tokenCoding6534_18; + operand.values[19] = tokenCoding6534_19; } -Coding x64Parser::tokenCoding5385_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5385_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6495[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6496, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6534, x64Parser::tokenBranches6534 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5385_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5385(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 451; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5385_16; - operand.values[17] = tokenCoding5385_17; - operand.values[19] = tokenCoding5385_19; -} -x64Token x64Parser::tokenBranches5379[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5380, - }, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5385, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5373[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5374}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5379}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5372[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5373}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5371[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5372}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5390_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6490[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5390_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6489[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5390_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5390(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5390_16; - operand.values[17] = tokenCoding5390_17; - operand.values[19] = tokenCoding5390_19; -} -x64Token x64Parser::tokenBranches5389[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5390, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5395_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5395_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5395_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5395(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5395_16; - operand.values[17] = tokenCoding5395_17; - operand.values[19] = tokenCoding5395_19; -} -x64Token x64Parser::tokenBranches5394[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5395, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5400_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5400_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5400_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5400(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5400_16; - operand.values[17] = tokenCoding5400_17; - operand.values[19] = tokenCoding5400_19; +void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6549_16; + operand.values[17] = tokenCoding6549_17; + operand.values[18] = tokenCoding6549_18; + operand.values[19] = tokenCoding6549_19; } -Coding x64Parser::tokenCoding5405_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6548[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6549, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5405_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5405_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5405(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5405_16; - operand.values[17] = tokenCoding5405_17; - operand.values[19] = tokenCoding5405_19; -} -x64Token x64Parser::tokenBranches5399[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5400, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5405, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5388[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5389}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5394}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5399}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5387[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5388}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5386[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5387}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5410_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5410_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5410_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5410(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5410_16; - operand.values[17] = tokenCoding5410_17; - operand.values[19] = tokenCoding5410_19; -} -x64Token x64Parser::tokenBranches5409[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5410, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5415_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5415_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6551_16; + operand.values[17] = tokenCoding6551_17; + operand.values[18] = tokenCoding6551_18; + operand.values[19] = tokenCoding6551_19; +} +x64Token x64Parser::tokenBranches6550[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6551, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5415_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5415(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5415_16; - operand.values[17] = tokenCoding5415_17; - operand.values[19] = tokenCoding5415_19; -} -x64Token x64Parser::tokenBranches5414[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5415, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5420_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5420_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5420_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5420(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5420_16; - operand.values[17] = tokenCoding5420_17; - operand.values[19] = tokenCoding5420_19; -} -x64Token x64Parser::tokenBranches5419[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5420, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5425_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5425_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5425_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5425(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5425_16; - operand.values[17] = tokenCoding5425_17; - operand.values[19] = tokenCoding5425_19; +void x64Parser::TokenFunc6553(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6553_16; + operand.values[17] = tokenCoding6553_17; + operand.values[18] = tokenCoding6553_18; + operand.values[19] = tokenCoding6553_19; } -Coding x64Parser::tokenCoding5430_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6552[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6553, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5430_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5430_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5430(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5430_16; - operand.values[17] = tokenCoding5430_17; - operand.values[19] = tokenCoding5430_19; -} -x64Token x64Parser::tokenBranches5424[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5425, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5430, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5408[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5409}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5414}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5419}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5424}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5407[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5408}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5406[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5407}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5434_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5434_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5434_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5434(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5434_16; - operand.values[17] = tokenCoding5434_17; - operand.values[19] = tokenCoding5434_19; -} -x64Token x64Parser::tokenBranches5433[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5434, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5432[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5433}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5431[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5432}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5438_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6555_16; + operand.values[17] = tokenCoding6555_17; + operand.values[18] = tokenCoding6555_18; + operand.values[19] = tokenCoding6555_19; +} +x64Token x64Parser::tokenBranches6554[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6472[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6473, x64Parser::tokenBranches6473 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6481, x64Parser::tokenBranches6481 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6489, x64Parser::tokenBranches6489 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 514; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6559[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6560, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6575(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 518; +} +x64Token x64Parser::tokenBranches6558[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6575, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6557[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 515; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6563[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6564, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 519; +} +x64Token x64Parser::tokenBranches6562[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6578, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 516; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6567[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6568, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 520; +} +x64Token x64Parser::tokenBranches6566[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 517; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6571[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6572, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5438_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 521; +} +x64Token x64Parser::tokenBranches6570[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5438_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5438(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5438_16; - operand.values[17] = tokenCoding5438_17; - operand.values[19] = tokenCoding5438_19; -} -x64Token x64Parser::tokenBranches5437[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5438, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5442_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5442_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6556[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5442_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5442(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5442_16; - operand.values[17] = tokenCoding5442_17; - operand.values[19] = tokenCoding5442_19; +void x64Parser::TokenFunc6593(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 522; } -Coding x64Parser::tokenCoding5446_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6592[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6593, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5446_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6591[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5446_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5446(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 451; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5446_16; - operand.values[17] = tokenCoding5446_17; - operand.values[19] = tokenCoding5446_19; -} -x64Token x64Parser::tokenBranches5441[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5442, - }, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5446, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5436[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5437}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5441}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5435[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5436}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5450_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6590[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5450_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6609(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 524; +} +x64Token x64Parser::tokenBranches6608[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6609, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5450_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5450(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5450_16; - operand.values[17] = tokenCoding5450_17; - operand.values[19] = tokenCoding5450_19; -} -x64Token x64Parser::tokenBranches5449[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5450, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5454_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6607[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5454_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6606[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5454_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5454(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5454_16; - operand.values[17] = tokenCoding5454_17; - operand.values[19] = tokenCoding5454_19; -} -x64Token x64Parser::tokenBranches5453[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5454, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5458_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6589[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5458_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6588[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5458_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5458(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5458_16; - operand.values[17] = tokenCoding5458_17; - operand.values[19] = tokenCoding5458_19; -} -Coding x64Parser::tokenCoding5462_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6587[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5462_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6601(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 523; +} +x64Token x64Parser::tokenBranches6600[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6601, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5462_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5462(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5462_16; - operand.values[17] = tokenCoding5462_17; - operand.values[19] = tokenCoding5462_19; -} -x64Token x64Parser::tokenBranches5457[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5458, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5462, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5448[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5449}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5453}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5457}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5447[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5448}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5466_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6599[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5466_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6598[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5466_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5466(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5466_16; - operand.values[17] = tokenCoding5466_17; - operand.values[19] = tokenCoding5466_19; -} -x64Token x64Parser::tokenBranches5465[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5466, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5470_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6617(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 525; +} +x64Token x64Parser::tokenBranches6616[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6617, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5470_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6615[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5470_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5470(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5470_16; - operand.values[17] = tokenCoding5470_17; - operand.values[19] = tokenCoding5470_19; -} -x64Token x64Parser::tokenBranches5469[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5470, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5474_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6614[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5474_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6631(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 527; +} +x64Token x64Parser::tokenBranches6630[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6631, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5474_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5474(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5474_16; - operand.values[17] = tokenCoding5474_17; - operand.values[19] = tokenCoding5474_19; -} -x64Token x64Parser::tokenBranches5473[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5474, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5478_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5478_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6628[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5478_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5478(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5478_16; - operand.values[17] = tokenCoding5478_17; - operand.values[19] = tokenCoding5478_19; -} -Coding x64Parser::tokenCoding5482_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6597[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5482_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6596[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5482_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5482(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 455; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5482_16; - operand.values[17] = tokenCoding5482_17; - operand.values[19] = tokenCoding5482_19; -} -x64Token x64Parser::tokenBranches5477[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5478, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5482, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5464[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5465}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5469}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5473}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5477}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5463[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5464}, {x64Token::EOT}}; -void x64Parser::TokenFunc5326(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5330(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5334(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5338(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5342(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches5309[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches5310}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5314}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5318}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5322}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc5326, x64Parser::tokenBranches5326}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc5330, x64Parser::tokenBranches5330}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5334, x64Parser::tokenBranches5334}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5338, x64Parser::tokenBranches5338}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5342, x64Parser::tokenBranches5342}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5346}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5354}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5358}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5362}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5366}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5371}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5386}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5406}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5431}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5435}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5447}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5463}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5488_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6622[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5488_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6621[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5488_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5488(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 456; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5488_16; - operand.values[17] = tokenCoding5488_17; - operand.values[19] = tokenCoding5488_19; -} -x64Token x64Parser::tokenBranches5487[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5488, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5502_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6620[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6595[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6596, x64Parser::tokenBranches6596 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6586[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5502(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5502_16; - operand.values[17] = tokenCoding5502_17; - operand.values[18] = tokenCoding5502_18; - operand.values[19] = tokenCoding5502_19; -} -x64Token x64Parser::tokenBranches5486[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5487}, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5502, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5485[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5486}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5484[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5485}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5493_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6639(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 528; +} +x64Token x64Parser::tokenBranches6638[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6639, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5493_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6637[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5493_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5493(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 457; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5493_16; - operand.values[17] = tokenCoding5493_17; - operand.values[19] = tokenCoding5493_19; -} -x64Token x64Parser::tokenBranches5492[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5493, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5506_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6636[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6655(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 530; +} +x64Token x64Parser::tokenBranches6654[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6655, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6653[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5506(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5506_16; - operand.values[17] = tokenCoding5506_17; - operand.values[18] = tokenCoding5506_18; - operand.values[19] = tokenCoding5506_19; -} -x64Token x64Parser::tokenBranches5491[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5492}, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5506, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5490[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5491}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5489[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5490}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5498_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6652[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5498_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6635[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5498_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5498(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 458; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5498_16; - operand.values[17] = tokenCoding5498_17; - operand.values[19] = tokenCoding5498_19; -} -x64Token x64Parser::tokenBranches5497[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5498, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5510_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6634[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6633[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6647(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 529; +} +x64Token x64Parser::tokenBranches6646[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6647, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5510(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5510_16; - operand.values[17] = tokenCoding5510_17; - operand.values[18] = tokenCoding5510_18; - operand.values[19] = tokenCoding5510_19; -} -x64Token x64Parser::tokenBranches5496[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5497}, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5510, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5495[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5496}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5494[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5495}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5483[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5484}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5489}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5494}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5520_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5520_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6644[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5520_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5520(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5520_16; - operand.values[17] = tokenCoding5520_17; - operand.values[19] = tokenCoding5520_19; -} -x64Token x64Parser::tokenBranches5519[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5520, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5522_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6663(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 531; +} +x64Token x64Parser::tokenBranches6662[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6663, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5522_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6661[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5522_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5522(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5522_16; - operand.values[17] = tokenCoding5522_17; - operand.values[19] = tokenCoding5522_19; -} -x64Token x64Parser::tokenBranches5521[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5522, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5524_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6660[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5524_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6677(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 533; +} +x64Token x64Parser::tokenBranches6676[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6677, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5524_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5524(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5524_16; - operand.values[17] = tokenCoding5524_17; - operand.values[19] = tokenCoding5524_19; -} -x64Token x64Parser::tokenBranches5523[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5524, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5526_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6675[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5526_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6674[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5526_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5526(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5526_16; - operand.values[17] = tokenCoding5526_17; - operand.values[19] = tokenCoding5526_19; -} -x64Token x64Parser::tokenBranches5525[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5526, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5512_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6643[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5512_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6642[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5512_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5512(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5512_16; - operand.values[17] = tokenCoding5512_17; - operand.values[19] = tokenCoding5512_19; -} -void x64Parser::TokenFunc5513(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 459; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5514(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 460; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5515(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 461; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 532; } -Coding x64Parser::tokenCoding5516_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6668[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5516_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6667[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5516_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6666[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5516(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5516_16; - operand.values[17] = tokenCoding5516_17; - operand.values[19] = tokenCoding5516_19; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -Coding x64Parser::tokenCoding5517_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5517_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6641[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6642, x64Parser::tokenBranches6642 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5517_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6632[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5517(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6685(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5517_16; - operand.values[17] = tokenCoding5517_17; - operand.values[19] = tokenCoding5517_19; + operand.operandCoding = 534; } -Coding x64Parser::tokenCoding5518_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5518_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6684[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6685, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5518_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5518(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5518_16; - operand.values[17] = tokenCoding5518_17; - operand.values[19] = tokenCoding5518_19; -} -x64Token x64Parser::tokenBranches5511[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5512, - }, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5513, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5514, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5515, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5516, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5517, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5518, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5519}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5521}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5523}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5525}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5533_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6683[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5533_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6682[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5533_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5533(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5533_16; - operand.values[17] = tokenCoding5533_17; - operand.values[19] = tokenCoding5533_19; -} -x64Token x64Parser::tokenBranches5532[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5533, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5535_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6701(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 536; +} +x64Token x64Parser::tokenBranches6700[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6701, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5535_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6699[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5535_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5535(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5535_16; - operand.values[17] = tokenCoding5535_17; - operand.values[19] = tokenCoding5535_19; -} -x64Token x64Parser::tokenBranches5534[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5535, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5537_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6698[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5537_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6681[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5537_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5537(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5537_16; - operand.values[17] = tokenCoding5537_17; - operand.values[19] = tokenCoding5537_19; -} -x64Token x64Parser::tokenBranches5536[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5537, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5539_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6680[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5539_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6679[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5539_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5539(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5539_16; - operand.values[17] = tokenCoding5539_17; - operand.values[19] = tokenCoding5539_19; -} -x64Token x64Parser::tokenBranches5538[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5539, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5528_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6693(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 535; +} +x64Token x64Parser::tokenBranches6692[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6693, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5528_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6691[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5528_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6690[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5528(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6709(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5528_16; - operand.values[17] = tokenCoding5528_17; - operand.values[19] = tokenCoding5528_19; + operand.operandCoding = 537; } -Coding x64Parser::tokenCoding5529_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6708[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6709, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5529_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6707[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5529_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6706[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5529(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6723(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5529_16; - operand.values[17] = tokenCoding5529_17; - operand.values[19] = tokenCoding5529_19; + operand.operandCoding = 539; } -Coding x64Parser::tokenCoding5530_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6722[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6723, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5530_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6721[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5530_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6720[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6689[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6688[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5530(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5530_16; - operand.values[17] = tokenCoding5530_17; - operand.values[19] = tokenCoding5530_19; + operand.operandCoding = 538; } -Coding x64Parser::tokenCoding5531_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6714[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5531_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6713[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5531_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5531(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5531_16; - operand.values[17] = tokenCoding5531_17; - operand.values[19] = tokenCoding5531_19; -} -x64Token x64Parser::tokenBranches5527[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5528, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5529, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5530, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5531, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5532}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5534}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5536}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5538}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5543(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5542[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc5543, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5541[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5542}, {x64Token::EOT}}; -void x64Parser::TokenFunc5546(x64Operand& operand, int tokenPos) { operand.operandCoding = 463; } -x64Token x64Parser::tokenBranches5545[] = {{ - x64Token::REGISTER, - 99, - 1, - 0, - NULL, - &x64Parser::TokenFunc5546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5544[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5545}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5549_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6712[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5549_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6687[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6688, x64Parser::tokenBranches6688 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6678[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6585[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 540; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6729[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6730, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6728[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5549_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5549(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5549_16; - operand.values[17] = tokenCoding5549_17; - operand.values[19] = tokenCoding5549_19; -} -x64Token x64Parser::tokenBranches5548[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5549, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5551_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5551_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5551_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5551_16; - operand.values[17] = tokenCoding5551_17; - operand.values[19] = tokenCoding5551_19; -} -x64Token x64Parser::tokenBranches5550[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5544(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5540[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches5541}, - {x64Token::REGISTERCLASS, 20, 1, 0, NULL, &x64Parser::TokenFunc5544, x64Parser::tokenBranches5544}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5548}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5550}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5555(x64Operand& operand, int tokenPos) { operand.operandCoding = 439; } -x64Token x64Parser::tokenBranches5554[] = {{ - x64Token::REGISTER, - 99, - 1, - 0, - NULL, - &x64Parser::TokenFunc5555, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5553[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5554}, {x64Token::EOT}}; -void x64Parser::TokenFunc5553(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 439; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5557(x64Operand& operand, int tokenPos) { operand.operandCoding = 464; } -x64Token x64Parser::tokenBranches5552[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL, &x64Parser::TokenFunc5553, x64Parser::tokenBranches5553}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5557, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5560_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5560_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6736_16; + operand.values[17] = tokenCoding6736_17; + operand.values[18] = tokenCoding6736_18; + operand.values[19] = tokenCoding6736_19; +} +x64Token x64Parser::tokenBranches6735[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6736, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6740(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 541; +} +x64Token x64Parser::tokenBranches6739[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6740, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 542; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6747[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6748, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 543; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6749[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6750, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 544; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6760[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6761, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 545; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6765[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6766, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6759[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6758[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5560_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5560(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5560_16; - operand.values[17] = tokenCoding5560_17; - operand.values[19] = tokenCoding5560_19; -} -x64Token x64Parser::tokenBranches5559[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5560, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5562_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5562_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5562_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5562(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5562_16; - operand.values[17] = tokenCoding5562_17; - operand.values[19] = tokenCoding5562_19; -} -x64Token x64Parser::tokenBranches5561[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5562, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5558[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5559}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5561}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5565_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5565_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5565(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5565_16; - operand.values[17] = tokenCoding5565_17; -} -x64Token x64Parser::tokenBranches5564[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5565, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5563[] = {{x64Token::TOKEN, 12, 0, 1, NULL, NULL, x64Parser::tokenBranches5564}, {x64Token::EOT}}; -void x64Parser::TokenFunc5568(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 465; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5567[] = {{ - x64Token::NUMBER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5568, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5570(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 466; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5572(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 467; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5569[] = {{ - x64Token::NUMBER, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc5570, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5573(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 466; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5574(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 467; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5566[] = {{x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches5567}, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5569}, - { - x64Token::NUMBER, - 11, - 1, - 0, - NULL, - &x64Parser::TokenFunc5573, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5574, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5579_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5579_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6775(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6775_16; + operand.values[17] = tokenCoding6775_17; + operand.values[18] = tokenCoding6775_18; + operand.values[19] = tokenCoding6775_19; +} +x64Token x64Parser::tokenBranches6774[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6775, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5579_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5579_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5579(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5579_16; - operand.values[17] = tokenCoding5579_17; - operand.values[18] = tokenCoding5579_18; - operand.values[19] = tokenCoding5579_19; -} -x64Token x64Parser::tokenBranches5578[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5579, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5577[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5578}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5576[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5577}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5583_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6778_16; + operand.values[17] = tokenCoding6778_17; + operand.values[18] = tokenCoding6778_18; + operand.values[19] = tokenCoding6778_19; +} +x64Token x64Parser::tokenBranches6777[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::number; + operand.values[2]->val = operands.size(); + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 546; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 547; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6772_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5583(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5583_16; - operand.values[17] = tokenCoding5583_17; - operand.values[18] = tokenCoding5583_18; - operand.values[19] = tokenCoding5583_19; -} -x64Token x64Parser::tokenBranches5582[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5583, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5581[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5582}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5580[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5581}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5587_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5587(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5587_16; - operand.values[17] = tokenCoding5587_17; - operand.values[18] = tokenCoding5587_18; - operand.values[19] = tokenCoding5587_19; -} -x64Token x64Parser::tokenBranches5586[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5587, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5585[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5586}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5584[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5585}, {x64Token::EOT}}; -void x64Parser::TokenFunc5576(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5580(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5584(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6772_16; + operand.values[17] = tokenCoding6772_17; + operand.values[18] = tokenCoding6772_18; + operand.values[19] = tokenCoding6772_19; } -x64Token x64Parser::tokenBranches5575[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5576, x64Parser::tokenBranches5576}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5580, x64Parser::tokenBranches5580}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5584, x64Parser::tokenBranches5584}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5590_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5590_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6757[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6758, x64Parser::tokenBranches6758 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6768, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6770, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6772, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 548; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6779[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6780, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 549; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 550; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6781[] = { + {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6782, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5590_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5590_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5590(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5590_16; - operand.values[17] = tokenCoding5590_17; - operand.values[18] = tokenCoding5590_18; - operand.values[19] = tokenCoding5590_19; -} -x64Token x64Parser::tokenBranches5589[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5590, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5588[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5589}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5604_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5604(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5604_16; - operand.values[17] = tokenCoding5604_17; - operand.values[18] = tokenCoding5604_18; - operand.values[19] = tokenCoding5604_19; -} -x64Token x64Parser::tokenBranches5603[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5604, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5594_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6792_16; + operand.values[17] = tokenCoding6792_17; + operand.values[18] = tokenCoding6792_18; + operand.values[19] = tokenCoding6792_19; +} +x64Token x64Parser::tokenBranches6791[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6792, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5594_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5594_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5594_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5594(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5594_16; - operand.values[17] = tokenCoding5594_17; - operand.values[18] = tokenCoding5594_18; - operand.values[19] = tokenCoding5594_19; -} -x64Token x64Parser::tokenBranches5593[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5594, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5603}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5592[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5593}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5608_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5608_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5608_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6794_16; + operand.values[17] = tokenCoding6794_17; + operand.values[18] = tokenCoding6794_18; + operand.values[19] = tokenCoding6794_19; +} +x64Token x64Parser::tokenBranches6793[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6794, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5608_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5608(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5608_16; - operand.values[17] = tokenCoding5608_17; - operand.values[18] = tokenCoding5608_18; - operand.values[19] = tokenCoding5608_19; -} -x64Token x64Parser::tokenBranches5607[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5608, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5612_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5612(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5612_16; - operand.values[17] = tokenCoding5612_17; - operand.values[18] = tokenCoding5612_18; - operand.values[19] = tokenCoding5612_19; -} -x64Token x64Parser::tokenBranches5611[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5612, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5597_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6796_16; + operand.values[17] = tokenCoding6796_17; + operand.values[18] = tokenCoding6796_18; + operand.values[19] = tokenCoding6796_19; +} +x64Token x64Parser::tokenBranches6795[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 549; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 550; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6787_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5597(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6787(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5597_16; - operand.values[17] = tokenCoding5597_17; - operand.values[18] = tokenCoding5597_18; - operand.values[19] = tokenCoding5597_19; + operand.values[16] = tokenCoding6787_16; + operand.values[17] = tokenCoding6787_17; + operand.values[18] = tokenCoding6787_18; + operand.values[19] = tokenCoding6787_19; } -Coding x64Parser::tokenCoding5600_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5600(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5600_16; - operand.values[17] = tokenCoding5600_17; - operand.values[18] = tokenCoding5600_18; - operand.values[19] = tokenCoding5600_19; -} -x64Token x64Parser::tokenBranches5596[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5597, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5600, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5607}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5611}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5595[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5596}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5625_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6788_16; + operand.values[17] = tokenCoding6788_17; + operand.values[18] = tokenCoding6788_18; + operand.values[19] = tokenCoding6788_19; +} +Coding x64Parser::tokenCoding6789_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5625(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5625_16; - operand.values[17] = tokenCoding5625_17; - operand.values[18] = tokenCoding5625_18; - operand.values[19] = tokenCoding5625_19; -} -x64Token x64Parser::tokenBranches5624[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5625, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5629_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6789(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6789_16; + operand.values[17] = tokenCoding6789_17; + operand.values[18] = tokenCoding6789_18; + operand.values[19] = tokenCoding6789_19; +} +Coding x64Parser::tokenCoding6790_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5629(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5629_16; - operand.values[17] = tokenCoding5629_17; - operand.values[18] = tokenCoding5629_18; - operand.values[19] = tokenCoding5629_19; -} -x64Token x64Parser::tokenBranches5628[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5629, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5633_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5633_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5633_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6790_16; + operand.values[17] = tokenCoding6790_17; + operand.values[18] = tokenCoding6790_18; + operand.values[19] = tokenCoding6790_19; +} +x64Token x64Parser::tokenBranches6756[] = { + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757 }, + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6785, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6786, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6787, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6788, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6789, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6790, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5633_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5633(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5633_16; - operand.values[17] = tokenCoding5633_17; - operand.values[18] = tokenCoding5633_18; - operand.values[19] = tokenCoding5633_19; -} -x64Token x64Parser::tokenBranches5632[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5633, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5615_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5615(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6830(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5615_16; - operand.values[17] = tokenCoding5615_17; - operand.values[18] = tokenCoding5615_18; - operand.values[19] = tokenCoding5615_19; + operand.values[16] = tokenCoding6830_16; + operand.values[17] = tokenCoding6830_17; + operand.values[18] = tokenCoding6830_18; + operand.values[19] = tokenCoding6830_19; } -Coding x64Parser::tokenCoding5618_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6829[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6830, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6837(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 551; +} +x64Token x64Parser::tokenBranches6836[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6837, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 553; +} +x64Token x64Parser::tokenBranches6848[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6835[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6834[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5618(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6843(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5618_16; - operand.values[17] = tokenCoding5618_17; - operand.values[18] = tokenCoding5618_18; - operand.values[19] = tokenCoding5618_19; + operand.operandCoding = 552; } -Coding x64Parser::tokenCoding5621_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5621_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6842[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6843, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5621_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6855(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 554; +} +x64Token x64Parser::tokenBranches6854[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6855, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5621_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5621(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5621_16; - operand.values[17] = tokenCoding5621_17; - operand.values[18] = tokenCoding5621_18; - operand.values[19] = tokenCoding5621_19; -} -x64Token x64Parser::tokenBranches5614[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5615, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5618, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5621, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5624}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5628}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5632}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5613[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5614}, {x64Token::EOT}}; -void x64Parser::TokenFunc5592(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5595(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5613(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches5591[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5592, x64Parser::tokenBranches5592}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5595, x64Parser::tokenBranches5595}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5613, x64Parser::tokenBranches5613}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5637_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6864[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5637_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6841[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5637_19[] = { - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5637(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5637_16; - operand.values[17] = tokenCoding5637_17; - operand.values[19] = tokenCoding5637_19; +x64Token x64Parser::tokenBranches6840[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6859(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 555; } -Coding x64Parser::tokenCoding5640_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6858[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6859, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5640_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6840(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6833[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6840, x64Parser::tokenBranches6840 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5640_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5640(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5640_16; - operand.values[17] = tokenCoding5640_17; - operand.values[19] = tokenCoding5640_19; +x64Token x64Parser::tokenBranches6832[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6871(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 557; } -Coding x64Parser::tokenCoding5643_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6870[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6871, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5643_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 559; +} +x64Token x64Parser::tokenBranches6882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5643_19[] = { - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5643(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5643_16; - operand.values[17] = tokenCoding5643_17; - operand.values[19] = tokenCoding5643_19; -} -x64Token x64Parser::tokenBranches5636[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5637, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5640, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5643, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5635[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5636}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5648_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6869[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5648_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6868[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5648_19[] = { - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5648(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5648_16; - operand.values[17] = tokenCoding5648_17; - operand.values[19] = tokenCoding5648_19; +void x64Parser::TokenFunc6877(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 558; } -Coding x64Parser::tokenCoding5653_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6876[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6877, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5653_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6889(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 560; +} +x64Token x64Parser::tokenBranches6888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6889, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5653_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5653(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5653_16; - operand.values[17] = tokenCoding5653_17; - operand.values[19] = tokenCoding5653_19; -} -x64Token x64Parser::tokenBranches5647[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5648, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5653, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5657_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 562; +} +x64Token x64Parser::tokenBranches6898[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5657_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6875[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5657_19[] = { - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5657(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5657_16; - operand.values[17] = tokenCoding5657_17; - operand.values[19] = tokenCoding5657_19; -} -x64Token x64Parser::tokenBranches5646[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5647}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5657, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5646}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5644[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5645}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5660_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6874[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5660_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6893(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 561; +} +x64Token x64Parser::tokenBranches6892[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6893, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5660_19[] = { - {CODING_NAME("one") Coding::stateFunc, 4}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5660(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5660_16; - operand.values[17] = tokenCoding5660_17; - operand.values[19] = tokenCoding5660_19; +void x64Parser::TokenFunc6874(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -Coding x64Parser::tokenCoding5663_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6867[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6874, x64Parser::tokenBranches6874 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5663_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6866[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5663_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5663(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5663_16; - operand.values[17] = tokenCoding5663_17; - operand.values[19] = tokenCoding5663_19; +void x64Parser::TokenFunc6905(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 563; } -Coding x64Parser::tokenCoding5666_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6904[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6905, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5666_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 565; +} +x64Token x64Parser::tokenBranches6916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5666_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5666(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5666_16; - operand.values[17] = tokenCoding5666_17; - operand.values[19] = tokenCoding5666_19; -} -x64Token x64Parser::tokenBranches5659[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5660, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5663, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5666, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5658[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5659}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5671_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6903[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5671_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6902[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5671_19[] = { - {CODING_NAME("one") Coding::stateFunc, 4}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5671(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5671_16; - operand.values[17] = tokenCoding5671_17; - operand.values[19] = tokenCoding5671_19; +void x64Parser::TokenFunc6911(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 564; } -Coding x64Parser::tokenCoding5676_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6910[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6911, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5676_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6923(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 566; +} +x64Token x64Parser::tokenBranches6922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6923, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5676_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5676(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5676_16; - operand.values[17] = tokenCoding5676_17; - operand.values[19] = tokenCoding5676_19; -} -x64Token x64Parser::tokenBranches5670[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5671, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5676, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5680_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 568; +} +x64Token x64Parser::tokenBranches6932[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5680_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6909[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5680_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5680(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5680_16; - operand.values[17] = tokenCoding5680_17; - operand.values[19] = tokenCoding5680_19; -} -x64Token x64Parser::tokenBranches5669[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5670}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5680, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5668[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5669}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5667[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5668}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5687_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6908[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5687_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6927(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 567; +} +x64Token x64Parser::tokenBranches6926[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6927, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5687_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5687(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5687_16; - operand.values[17] = tokenCoding5687_17; - operand.values[19] = tokenCoding5687_19; -} -x64Token x64Parser::tokenBranches5686[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5687, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5683_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6901[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6908, x64Parser::tokenBranches6908 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5683_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6900[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5683_19[] = { - {CODING_NAME("one") Coding::stateFunc, 5}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5683(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5683_16; - operand.values[17] = tokenCoding5683_17; - operand.values[19] = tokenCoding5683_19; +void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 569; } -Coding x64Parser::tokenCoding5690_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6938[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5690_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6937[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5690_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5690(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5690_16; - operand.values[17] = tokenCoding5690_17; - operand.values[19] = tokenCoding5690_19; -} -x64Token x64Parser::tokenBranches5682[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5683, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5686}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5690, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5681[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5682}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5695_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6936[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5695_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 570; +} +x64Token x64Parser::tokenBranches6944[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5695_19[] = { - {CODING_NAME("one") Coding::stateFunc, 5}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5695(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5695_16; - operand.values[17] = tokenCoding5695_17; - operand.values[19] = tokenCoding5695_19; +void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 572; } -Coding x64Parser::tokenCoding5700_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6954[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5700_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6943[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5700_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5700(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5700_16; - operand.values[17] = tokenCoding5700_17; - operand.values[19] = tokenCoding5700_19; -} -x64Token x64Parser::tokenBranches5694[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5695, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5700, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5704_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6942[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5704_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6949(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 571; +} +x64Token x64Parser::tokenBranches6948[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6949, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5704_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5704(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5704_16; - operand.values[17] = tokenCoding5704_17; - operand.values[19] = tokenCoding5704_19; -} -x64Token x64Parser::tokenBranches5693[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5694}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5704, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5692[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5693}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5691[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5692}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5711_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6935[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6942, x64Parser::tokenBranches6942 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6934[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6831[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6960(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 573; +} +x64Token x64Parser::tokenBranches6959[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6960, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 574; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6961[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6962, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 575; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6963[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6964, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 576; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6965[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6966, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 576; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6967[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 575; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6969[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5711_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5711_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5711(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5711_16; - operand.values[17] = tokenCoding5711_17; - operand.values[19] = tokenCoding5711_19; -} -x64Token x64Parser::tokenBranches5710[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5711, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5707_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5707_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5707_19[] = { - {CODING_NAME("one") Coding::stateFunc, 6}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5707(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5707_16; - operand.values[17] = tokenCoding5707_17; - operand.values[19] = tokenCoding5707_19; +Coding x64Parser::tokenCoding6974_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6974_16; + operand.values[17] = tokenCoding6974_17; + operand.values[18] = tokenCoding6974_18; + operand.values[19] = tokenCoding6974_19; } -Coding x64Parser::tokenCoding5714_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6973[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6974, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5714_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5714_19[] = { - {CODING_NAME("") Coding::stateFunc, 6}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5714(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5714_16; - operand.values[17] = tokenCoding5714_17; - operand.values[19] = tokenCoding5714_19; -} -x64Token x64Parser::tokenBranches5706[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5707, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5710}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5714, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5705[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5706}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5719_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5719_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5719_19[] = { - {CODING_NAME("one") Coding::stateFunc, 6}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5719(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5719_16; - operand.values[17] = tokenCoding5719_17; - operand.values[19] = tokenCoding5719_19; -} -Coding x64Parser::tokenCoding5724_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5724_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6978(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6978_16; + operand.values[17] = tokenCoding6978_17; + operand.values[18] = tokenCoding6978_18; + operand.values[19] = tokenCoding6978_19; +} +x64Token x64Parser::tokenBranches6977[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6978, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5724_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5724(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5724_16; - operand.values[17] = tokenCoding5724_17; - operand.values[19] = tokenCoding5724_19; -} -x64Token x64Parser::tokenBranches5718[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5719, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5724, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5728_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6976[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5728_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5728_19[] = { - {CODING_NAME("") Coding::stateFunc, 6}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5728(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5728_16; - operand.values[17] = tokenCoding5728_17; - operand.values[19] = tokenCoding5728_19; -} -x64Token x64Parser::tokenBranches5717[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5718}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5728, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5716[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5717}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5715[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5716}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5634[] = {{x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5635}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5644}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5658}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5667}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5681}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5691}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5705}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5715}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5735_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5735(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5735_16; - operand.values[17] = tokenCoding5735_17; - operand.values[18] = tokenCoding5735_18; - operand.values[19] = tokenCoding5735_19; +void x64Parser::TokenFunc6981(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6981_16; + operand.values[17] = tokenCoding6981_17; + operand.values[18] = tokenCoding6981_18; + operand.values[19] = tokenCoding6981_19; } -Coding x64Parser::tokenCoding5741_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6980[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6981, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5741_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5741_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6979[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5741_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5741(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5741_16; - operand.values[17] = tokenCoding5741_17; - operand.values[18] = tokenCoding5741_18; - operand.values[19] = tokenCoding5741_19; -} -x64Token x64Parser::tokenBranches5734[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5735, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5741, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5733[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5734}, {x64Token::EOT}}; -void x64Parser::TokenFunc5733(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5732[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5733, x64Parser::tokenBranches5733}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5731[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5732}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5730[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5731}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5747_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5747(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5747_16; - operand.values[17] = tokenCoding5747_17; - operand.values[18] = tokenCoding5747_18; - operand.values[19] = tokenCoding5747_19; -} -Coding x64Parser::tokenCoding5753_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5753_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6984_16; + operand.values[17] = tokenCoding6984_17; + operand.values[18] = tokenCoding6984_18; + operand.values[19] = tokenCoding6984_19; +} +x64Token x64Parser::tokenBranches6983[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5753_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6982[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5753_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5753(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5753_16; - operand.values[17] = tokenCoding5753_17; - operand.values[18] = tokenCoding5753_18; - operand.values[19] = tokenCoding5753_19; -} -x64Token x64Parser::tokenBranches5746[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5747, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5753, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5745[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5746}, {x64Token::EOT}}; -void x64Parser::TokenFunc5745(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 577; } -x64Token x64Parser::tokenBranches5744[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5745, x64Parser::tokenBranches5745}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5743[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5744}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5742[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5743}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5759_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6989[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6990, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6998(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 578; +} +x64Token x64Parser::tokenBranches6997[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6998, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7012(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 580; +} +x64Token x64Parser::tokenBranches7011[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7012, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5759(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5759_16; - operand.values[17] = tokenCoding5759_17; - operand.values[18] = tokenCoding5759_18; - operand.values[19] = tokenCoding5759_19; +void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5765_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6996[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6997, x64Parser::tokenBranches6997 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7011, x64Parser::tokenBranches7011 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6995[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 579; +} +x64Token x64Parser::tokenBranches7003[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6988[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6989, x64Parser::tokenBranches6989 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6987[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6986[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5765(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5765_16; - operand.values[17] = tokenCoding5765_17; - operand.values[18] = tokenCoding5765_18; - operand.values[19] = tokenCoding5765_19; -} -x64Token x64Parser::tokenBranches5758[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5759, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5765, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5757[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5758}, {x64Token::EOT}}; -void x64Parser::TokenFunc5757(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +x64Token x64Parser::tokenBranches6985[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches5756[] = { - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5757, x64Parser::tokenBranches5757}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5755[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5756}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5754[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5755}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5729[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5730}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5742}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5754}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5767_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7017[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5767_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5767(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5767_16; - operand.values[17] = tokenCoding5767_17; -} -x64Token x64Parser::tokenBranches5766[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5767, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5771_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7026(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 582; +} +x64Token x64Parser::tokenBranches7025[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7026, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5771_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7040(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 584; +} +x64Token x64Parser::tokenBranches7039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7040, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5771_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5771(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5771_16; - operand.values[17] = tokenCoding5771_17; - operand.values[18] = tokenCoding5771_18; -} -x64Token x64Parser::tokenBranches5770[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5771, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5769[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5770}, {x64Token::EOT}}; -void x64Parser::TokenFunc5769(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5768[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5769, x64Parser::tokenBranches5769}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5775_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7024[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7025, x64Parser::tokenBranches7025 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7039, x64Parser::tokenBranches7039 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7023[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 583; +} +x64Token x64Parser::tokenBranches7031[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7016[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7015[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7014[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5775(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5775_16; - operand.values[17] = tokenCoding5775_17; - operand.values[18] = tokenCoding5775_18; - operand.values[19] = tokenCoding5775_19; -} -x64Token x64Parser::tokenBranches5774[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5775, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5773[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5774}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5778_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7013[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 585; +} +x64Token x64Parser::tokenBranches7045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7054(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 586; +} +x64Token x64Parser::tokenBranches7053[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7054, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5778(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5778_16; - operand.values[17] = tokenCoding5778_17; - operand.values[18] = tokenCoding5778_18; - operand.values[19] = tokenCoding5778_19; -} -x64Token x64Parser::tokenBranches5777[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5778, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5776[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5777}, {x64Token::EOT}}; -void x64Parser::TokenFunc5773(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7068(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches5772[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5773, x64Parser::tokenBranches5773}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5776}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5782_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7068, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5782_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7052[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7053, x64Parser::tokenBranches7053 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7067, x64Parser::tokenBranches7067 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7051[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 587; +} +x64Token x64Parser::tokenBranches7059[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7044[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7043[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7042[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7041[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 589; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7092_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5782_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5782_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5782(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5782_16; - operand.values[17] = tokenCoding5782_17; - operand.values[18] = tokenCoding5782_18; - operand.values[19] = tokenCoding5782_19; -} -x64Token x64Parser::tokenBranches5781[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5782, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5780[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5781}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5785_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7092(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7092_16; + operand.values[17] = tokenCoding7092_17; + operand.values[18] = tokenCoding7092_18; + operand.values[19] = tokenCoding7092_19; +} +x64Token x64Parser::tokenBranches7071[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7072, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7092, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7070[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7069[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 590; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7096_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7096_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5785(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5785_16; - operand.values[17] = tokenCoding5785_17; - operand.values[18] = tokenCoding5785_18; - operand.values[19] = tokenCoding5785_19; -} -x64Token x64Parser::tokenBranches5784[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5785, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5783[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5784}, {x64Token::EOT}}; -void x64Parser::TokenFunc5780(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7096_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7096_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7096_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7096(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7096_16; + operand.values[17] = tokenCoding7096_17; + operand.values[23] = tokenCoding7096_23; + operand.values[18] = tokenCoding7096_18; + operand.values[19] = tokenCoding7096_19; +} +x64Token x64Parser::tokenBranches7075[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7076, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7096, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7074[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7073[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 591; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5779[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5780, x64Parser::tokenBranches5780}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5783}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5789_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5789(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5789_16; - operand.values[17] = tokenCoding5789_17; - operand.values[18] = tokenCoding5789_18; - operand.values[19] = tokenCoding5789_19; -} -x64Token x64Parser::tokenBranches5788[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5789, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5787[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5788}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5792_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7100(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7100_16; + operand.values[17] = tokenCoding7100_17; + operand.values[18] = tokenCoding7100_18; + operand.values[19] = tokenCoding7100_19; +} +x64Token x64Parser::tokenBranches7079[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7080, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7100, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7078[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7077[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 592; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7104_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7104_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7104_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5792(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5792_16; - operand.values[17] = tokenCoding5792_17; - operand.values[18] = tokenCoding5792_18; - operand.values[19] = tokenCoding5792_19; -} -x64Token x64Parser::tokenBranches5791[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5792, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5790[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5791}, {x64Token::EOT}}; -void x64Parser::TokenFunc5787(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7104_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7104(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7104_16; + operand.values[17] = tokenCoding7104_17; + operand.values[18] = tokenCoding7104_18; + operand.values[19] = tokenCoding7104_19; +} +x64Token x64Parser::tokenBranches7083[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7084, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7104, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7082[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7081[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 593; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5786[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5787, x64Parser::tokenBranches5787}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5790}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5796_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5796_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5796_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5796(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5796_16; - operand.values[17] = tokenCoding5796_17; - operand.values[18] = tokenCoding5796_18; -} -x64Token x64Parser::tokenBranches5795[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5796, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5794[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5795}, {x64Token::EOT}}; -void x64Parser::TokenFunc5794(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5793[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5794, x64Parser::tokenBranches5794}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5800_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5800_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5800_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5800(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5800_16; - operand.values[17] = tokenCoding5800_17; - operand.values[18] = tokenCoding5800_18; -} -x64Token x64Parser::tokenBranches5799[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5800, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5798[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5799}, {x64Token::EOT}}; -void x64Parser::TokenFunc5798(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7108(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7108_16; + operand.values[17] = tokenCoding7108_17; + operand.values[18] = tokenCoding7108_18; + operand.values[19] = tokenCoding7108_19; } -x64Token x64Parser::tokenBranches5797[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5798, x64Parser::tokenBranches5798}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5804_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7087[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7088, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7108, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5804_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7086[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5804_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5804(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5804_16; - operand.values[17] = tokenCoding5804_17; - operand.values[18] = tokenCoding5804_18; -} -x64Token x64Parser::tokenBranches5803[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc5804, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5802[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5803}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5807_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7085[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5807_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5807_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5807(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5807_16; - operand.values[17] = tokenCoding5807_17; - operand.values[18] = tokenCoding5807_18; -} -x64Token x64Parser::tokenBranches5806[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc5807, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5805[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5806}, {x64Token::EOT}}; -void x64Parser::TokenFunc5802(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5805(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5801[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5802, x64Parser::tokenBranches5802}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5805, x64Parser::tokenBranches5805}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5812_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5812_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5812_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5812(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5812_16; - operand.values[17] = tokenCoding5812_17; - operand.values[18] = tokenCoding5812_18; -} -x64Token x64Parser::tokenBranches5811[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5812, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5816_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7113_16; + operand.values[17] = tokenCoding7113_17; + operand.values[18] = tokenCoding7113_18; + operand.values[19] = tokenCoding7113_19; +} +x64Token x64Parser::tokenBranches7112[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7113, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7111[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7110[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7109[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5816_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5816_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5816(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5816_16; - operand.values[17] = tokenCoding5816_17; - operand.values[18] = tokenCoding5816_18; -} -x64Token x64Parser::tokenBranches5815[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5816, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5810[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5811}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5815}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5809[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5810}, {x64Token::EOT}}; -void x64Parser::TokenFunc5809(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5808[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5809, x64Parser::tokenBranches5809}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5820_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5820_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5820_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7118_16; + operand.values[17] = tokenCoding7118_17; + operand.values[18] = tokenCoding7118_18; + operand.values[19] = tokenCoding7118_19; +} +x64Token x64Parser::tokenBranches7117[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7118, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7116[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7115[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7114[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5820_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5820(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5820_16; - operand.values[17] = tokenCoding5820_17; - operand.values[23] = tokenCoding5820_23; - operand.values[18] = tokenCoding5820_18; -} -x64Token x64Parser::tokenBranches5819[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5820, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5818[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5819}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5823_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5823(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5823_16; - operand.values[17] = tokenCoding5823_17; - operand.values[23] = tokenCoding5823_23; - operand.values[18] = tokenCoding5823_18; -} -x64Token x64Parser::tokenBranches5822[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5823, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5821[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5822}, {x64Token::EOT}}; -void x64Parser::TokenFunc5818(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5821(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5817[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5818, x64Parser::tokenBranches5818}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5821, x64Parser::tokenBranches5821}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5829_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7123_16; + operand.values[17] = tokenCoding7123_17; + operand.values[18] = tokenCoding7123_18; + operand.values[19] = tokenCoding7123_19; +} +x64Token x64Parser::tokenBranches7122[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7123, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7121[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7120[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7119[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5829_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5829_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5829(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5829_16; - operand.values[17] = tokenCoding5829_17; - operand.values[18] = tokenCoding5829_18; -} -x64Token x64Parser::tokenBranches5828[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5829, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5827[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5828}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5826[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5827}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5825[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5826}, {x64Token::EOT}}; -void x64Parser::TokenFunc5825(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5824[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5825, x64Parser::tokenBranches5825}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5833_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7128_16; + operand.values[17] = tokenCoding7128_17; + operand.values[18] = tokenCoding7128_18; + operand.values[19] = tokenCoding7128_19; +} +x64Token x64Parser::tokenBranches7127[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7128, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7126[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7125[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7124[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5833_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7279_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5833(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5833_16; - operand.values[17] = tokenCoding5833_17; - operand.values[23] = tokenCoding5833_23; - operand.values[18] = tokenCoding5833_18; - operand.values[19] = tokenCoding5833_19; -} -x64Token x64Parser::tokenBranches5832[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5833, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5831[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5832}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5836_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7279_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7279_18; + operand.values[19] = tokenCoding7279_19; +} +x64Token x64Parser::tokenBranches7278[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7279, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5836_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_16[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_17[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_18[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5836(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5836_16; - operand.values[17] = tokenCoding5836_17; - operand.values[23] = tokenCoding5836_23; - operand.values[18] = tokenCoding5836_18; - operand.values[19] = tokenCoding5836_19; -} -x64Token x64Parser::tokenBranches5835[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5836, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5834[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5835}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5839_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_19[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) +{ + operand.values[30] = new Coding[2]; + CleanupValues.push_back(operand.values[30]); + operand.values[30]->type = Coding::reg; + operand.values[30]->val = inputTokens[tokenPos]->val->ival; + operand.values[30]->bits = 0; + operand.values[30]->field = 0; + operand.values[30]->unary = 0; + operand.values[30]->binary = 0; + operand.values[30][1].type = Coding::eot; + operand.values[16] = tokenCoding7131_16; + operand.values[17] = tokenCoding7131_17; + operand.values[18] = tokenCoding7131_18; + operand.values[19] = tokenCoding7131_19; +} +Coding x64Parser::tokenCoding7134_16[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_17[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_18[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_19[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) +{ + operand.values[31] = new Coding[2]; + CleanupValues.push_back(operand.values[31]); + operand.values[31]->type = Coding::reg; + operand.values[31]->val = inputTokens[tokenPos]->val->ival; + operand.values[31]->bits = 0; + operand.values[31]->field = 0; + operand.values[31]->unary = 0; + operand.values[31]->binary = 0; + operand.values[31][1].type = Coding::eot; + operand.values[16] = tokenCoding7134_16; + operand.values[17] = tokenCoding7134_17; + operand.values[18] = tokenCoding7134_18; + operand.values[19] = tokenCoding7134_19; +} +Coding x64Parser::tokenCoding7137_16[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5839(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5839_16; - operand.values[17] = tokenCoding5839_17; - operand.values[23] = tokenCoding5839_23; - operand.values[18] = tokenCoding5839_18; - operand.values[19] = tokenCoding5839_19; -} -x64Token x64Parser::tokenBranches5838[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5839, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5837[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5838}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5842_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_17[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_18[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_19[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) +{ + operand.values[32] = new Coding[2]; + CleanupValues.push_back(operand.values[32]); + operand.values[32]->type = Coding::reg; + operand.values[32]->val = inputTokens[tokenPos]->val->ival; + operand.values[32]->bits = 0; + operand.values[32]->field = 0; + operand.values[32]->unary = 0; + operand.values[32]->binary = 0; + operand.values[32][1].type = Coding::eot; + operand.values[16] = tokenCoding7137_16; + operand.values[17] = tokenCoding7137_17; + operand.values[18] = tokenCoding7137_18; + operand.values[19] = tokenCoding7137_19; +} +Coding x64Parser::tokenCoding7264_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7264_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5842(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5842_16; - operand.values[17] = tokenCoding5842_17; - operand.values[23] = tokenCoding5842_23; - operand.values[18] = tokenCoding5842_18; - operand.values[19] = tokenCoding5842_19; -} -x64Token x64Parser::tokenBranches5841[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5842, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5840[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5841}, {x64Token::EOT}}; -void x64Parser::TokenFunc5837(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5840(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7264_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7264_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7264_16; + operand.values[17] = tokenCoding7264_17; + operand.values[18] = tokenCoding7264_18; + operand.values[19] = tokenCoding7264_19; +} +x64Token x64Parser::tokenBranches7130[] = { + {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7131, }, + {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7134, }, + {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7137, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7129[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 594; +} +x64Token x64Parser::tokenBranches7142[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7143, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7141[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7140[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7151(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 595; +} +x64Token x64Parser::tokenBranches7150[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7151, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7149[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7148[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7165(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 597; +} +x64Token x64Parser::tokenBranches7164[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7165, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7163[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7162[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5830[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches5831}, - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches5834}, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5837, x64Parser::tokenBranches5837}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5840, x64Parser::tokenBranches5840}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5848_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7147[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7148, x64Parser::tokenBranches7148 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7162, x64Parser::tokenBranches7162 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7146[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 596; +} +x64Token x64Parser::tokenBranches7156[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7155[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7154[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7139[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7140, x64Parser::tokenBranches7140 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5848_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5848_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5848(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5848_16; - operand.values[17] = tokenCoding5848_17; - operand.values[18] = tokenCoding5848_18; -} -x64Token x64Parser::tokenBranches5847[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5848, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5846[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5847}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5845[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5846}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5844[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5845}, {x64Token::EOT}}; -void x64Parser::TokenFunc5844(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5843[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5844, x64Parser::tokenBranches5844}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5854_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5854_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5854_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5854(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5854_16; - operand.values[17] = tokenCoding5854_17; - operand.values[18] = tokenCoding5854_18; -} -x64Token x64Parser::tokenBranches5853[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5854, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5852[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5853}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5851[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5852}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5850[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5851}, {x64Token::EOT}}; -void x64Parser::TokenFunc5850(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7225_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7225_16; + operand.values[17] = tokenCoding7225_17; + operand.values[18] = tokenCoding7225_18; + operand.values[19] = tokenCoding7225_19; } -x64Token x64Parser::tokenBranches5849[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5850, x64Parser::tokenBranches5850}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5865_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5865_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5865_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5865_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5865(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5865_16; - operand.values[17] = tokenCoding5865_17; - operand.values[18] = tokenCoding5865_18; - operand.values[19] = tokenCoding5865_19; -} -x64Token x64Parser::tokenBranches5864[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5865, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5863[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5864}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5862[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5863}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5870_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5870_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5870_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5870(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 469; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5870_16; - operand.values[17] = tokenCoding5870_17; - operand.values[18] = tokenCoding5870_18; +Coding x64Parser::tokenCoding7229_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7229_16; + operand.values[17] = tokenCoding7229_17; + operand.values[23] = tokenCoding7229_23; + operand.values[18] = tokenCoding7229_18; + operand.values[19] = tokenCoding7229_19; +} +x64Token x64Parser::tokenBranches7224[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7225, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7229, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7223[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7138[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 598; +} +x64Token x64Parser::tokenBranches7170[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7171, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7169[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7168[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7179(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 599; +} +x64Token x64Parser::tokenBranches7178[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7179, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7177[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7176[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7193(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 601; +} +x64Token x64Parser::tokenBranches7192[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7193, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7191[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7190[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5871_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7175[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7176, x64Parser::tokenBranches7176 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7190, x64Parser::tokenBranches7190 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7174[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 600; +} +x64Token x64Parser::tokenBranches7184[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7183[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7182[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7167[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5871_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5871_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5871(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 470; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5871_16; - operand.values[17] = tokenCoding5871_17; - operand.values[18] = tokenCoding5871_18; -} -x64Token x64Parser::tokenBranches5869[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5870, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5880(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 471; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5879[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc5880, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5884(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 472; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5883[] = {{ - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5884, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5878[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5879}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5883}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5877[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5878}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5892_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7233_16; + operand.values[17] = tokenCoding7233_17; + operand.values[18] = tokenCoding7233_18; + operand.values[19] = tokenCoding7233_19; +} +Coding x64Parser::tokenCoding7258_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5892(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5892_16; - operand.values[17] = tokenCoding5892_17; - operand.values[18] = tokenCoding5892_18; - operand.values[19] = tokenCoding5892_19; -} -x64Token x64Parser::tokenBranches5891[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5892, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5894_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5894_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5894_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7258_16; + operand.values[17] = tokenCoding7258_17; + operand.values[18] = tokenCoding7258_18; + operand.values[19] = tokenCoding7258_19; +} +x64Token x64Parser::tokenBranches7232[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7233, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7258, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7231[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7166[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 602; +} +x64Token x64Parser::tokenBranches7198[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7199, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7207(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 603; +} +x64Token x64Parser::tokenBranches7206[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7207, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7205[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7204[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7221(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 605; +} +x64Token x64Parser::tokenBranches7220[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7221, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7219[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7218[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7204(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7218(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7203[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7204, x64Parser::tokenBranches7204 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7218, x64Parser::tokenBranches7218 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7202[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7213(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 604; +} +x64Token x64Parser::tokenBranches7212[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7213, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7211[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7212 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7210[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7195[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5894_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5894(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5894_16; - operand.values[17] = tokenCoding5894_17; - operand.values[18] = tokenCoding5894_18; - operand.values[19] = tokenCoding5894_19; -} -x64Token x64Parser::tokenBranches5893[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5894, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5896_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5896(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5896_16; - operand.values[17] = tokenCoding5896_17; - operand.values[18] = tokenCoding5896_18; - operand.values[19] = tokenCoding5896_19; -} -x64Token x64Parser::tokenBranches5895[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5896, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5905_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7237_16; + operand.values[17] = tokenCoding7237_17; + operand.values[18] = tokenCoding7237_18; + operand.values[19] = tokenCoding7237_19; +} +x64Token x64Parser::tokenBranches7236[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7237, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7235[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7194[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5905_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5905_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5905_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5905(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5905_16; - operand.values[17] = tokenCoding5905_17; - operand.values[18] = tokenCoding5905_18; - operand.values[19] = tokenCoding5905_19; -} -x64Token x64Parser::tokenBranches5904[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5905, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5908_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5908_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7241_16; + operand.values[17] = tokenCoding7241_17; + operand.values[18] = tokenCoding7241_18; + operand.values[19] = tokenCoding7241_19; +} +x64Token x64Parser::tokenBranches7240[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7241, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7239[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7238[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5908_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5908_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5908(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5908_16; - operand.values[17] = tokenCoding5908_17; - operand.values[18] = tokenCoding5908_18; - operand.values[19] = tokenCoding5908_19; -} -x64Token x64Parser::tokenBranches5907[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5898(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 475; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5900(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 476; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding5902_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5902(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5902_16; - operand.values[17] = tokenCoding5902_17; - operand.values[18] = tokenCoding5902_18; - operand.values[19] = tokenCoding5902_19; -} -x64Token x64Parser::tokenBranches5897[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc5898, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5900, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5902, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5904}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5907}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5877(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::number; - operand.values[2]->val = operands.size(); - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5885(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 473; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5886(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 474; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7245(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7245_16; + operand.values[17] = tokenCoding7245_17; + operand.values[18] = tokenCoding7245_18; + operand.values[19] = tokenCoding7245_19; } -Coding x64Parser::tokenCoding5887_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7244[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7245, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5887_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5887_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5887_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7248_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5887(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5887_16; - operand.values[17] = tokenCoding5887_17; - operand.values[18] = tokenCoding5887_18; - operand.values[19] = tokenCoding5887_19; + operand.values[16] = tokenCoding7248_16; + operand.values[17] = tokenCoding7248_17; + operand.values[18] = tokenCoding7248_18; + operand.values[19] = tokenCoding7248_19; } -Coding x64Parser::tokenCoding5888_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5888(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5888_16; - operand.values[17] = tokenCoding5888_17; - operand.values[18] = tokenCoding5888_18; - operand.values[19] = tokenCoding5888_19; + operand.values[16] = tokenCoding7251_16; + operand.values[17] = tokenCoding7251_17; + operand.values[18] = tokenCoding7251_18; + operand.values[19] = tokenCoding7251_19; } -Coding x64Parser::tokenCoding5889_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5889(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5889_16; - operand.values[17] = tokenCoding5889_17; - operand.values[18] = tokenCoding5889_18; - operand.values[19] = tokenCoding5889_19; + operand.values[16] = tokenCoding7254_16; + operand.values[17] = tokenCoding7254_17; + operand.values[18] = tokenCoding7254_18; + operand.values[19] = tokenCoding7254_19; } -Coding x64Parser::tokenCoding5890_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7243[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7248, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7251, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7254, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5890_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7242[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5890_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7275_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5890_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7275_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7275_18; + operand.values[19] = tokenCoding7275_19; +} +x64Token x64Parser::tokenBranches7274[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7275, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5890(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5890_16; - operand.values[17] = tokenCoding5890_17; - operand.values[18] = tokenCoding5890_18; - operand.values[19] = tokenCoding5890_19; -} -x64Token x64Parser::tokenBranches5876[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc5877, x64Parser::tokenBranches5877}, - { - x64Token::NUMBER, - 13, - 1, - 0, - NULL, - &x64Parser::TokenFunc5885, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5886, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5887, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5888, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5889, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5890, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5891}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5893}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5895}, - {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches5897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5912(x64Operand& operand, int tokenPos) { operand.operandCoding = 477; } -x64Token x64Parser::tokenBranches5911[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5912, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5962(x64Operand& operand, int tokenPos) { operand.operandCoding = 478; } -x64Token x64Parser::tokenBranches5961[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5962, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5960[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5961}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5959[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5960}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5958[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5959}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5957[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5958}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5956[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5957}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5955[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5956}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5954[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5955}, {x64Token::EOT}}; -void x64Parser::TokenFunc5988(x64Operand& operand, int tokenPos) { operand.operandCoding = 480; } -x64Token x64Parser::tokenBranches5987[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5988, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5986[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches5987}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5985[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5986}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5984[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5985}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5983[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5984}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5982[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5983}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5981[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5982}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5980[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5981}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5953[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5954}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5980}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5952[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5953}, {x64Token::EOT}}; -void x64Parser::TokenFunc5975(x64Operand& operand, int tokenPos) { operand.operandCoding = 479; } -x64Token x64Parser::tokenBranches5974[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5975, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5973[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5974}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5972[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5973}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5971[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5972}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5970[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5971}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5969[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5970}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5968[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5969}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5967[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5968}, {x64Token::EOT}}; -void x64Parser::TokenFunc6001(x64Operand& operand, int tokenPos) { operand.operandCoding = 481; } -x64Token x64Parser::tokenBranches6000[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6001, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5999[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6000}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5998[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5999}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5997[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5998}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5996[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5997}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5995[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5996}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5994[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5995}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5993[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5994}, {x64Token::EOT}}; -void x64Parser::TokenFunc6023(x64Operand& operand, int tokenPos) { operand.operandCoding = 483; } -x64Token x64Parser::tokenBranches6022[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6023, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6021[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6022}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6020[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6021}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6019[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6020}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6018[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6019}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6017[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6018}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6016[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6017}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6015[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6016}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5966[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5967}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5993}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6015}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5965[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5966}, {x64Token::EOT}}; -void x64Parser::TokenFunc6010(x64Operand& operand, int tokenPos) { operand.operandCoding = 482; } -x64Token x64Parser::tokenBranches6009[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6010, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6008[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6009}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6007[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6008}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6006[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6007}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6005[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6006}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6004[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6005}, {x64Token::EOT}}; -void x64Parser::TokenFunc5965(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5951[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches5952}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc5965, x64Parser::tokenBranches5965}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6004}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5950[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5951}, {x64Token::EOT}}; -void x64Parser::TokenFunc6036(x64Operand& operand, int tokenPos) { operand.operandCoding = 484; } -x64Token x64Parser::tokenBranches6035[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6036, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6034[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6035}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6033[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6034}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6032[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6033}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6031[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6032}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6030[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6031}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6029[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6030}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6028[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6029}, {x64Token::EOT}}; -void x64Parser::TokenFunc6062(x64Operand& operand, int tokenPos) { operand.operandCoding = 486; } -x64Token x64Parser::tokenBranches6061[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6062, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6060[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6061}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6059[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6060}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6058[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6059}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6057[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6058}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6056[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6057}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6055[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6056}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6054[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6055}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6027[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6028}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6054}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6026[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6027}, {x64Token::EOT}}; -void x64Parser::TokenFunc6049(x64Operand& operand, int tokenPos) { operand.operandCoding = 485; } -x64Token x64Parser::tokenBranches6048[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6049, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6047[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6048}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6046[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6047}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6045[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6046}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6044[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6045}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6043[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6044}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6042[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6043}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6041[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6042}, {x64Token::EOT}}; -void x64Parser::TokenFunc6075(x64Operand& operand, int tokenPos) { operand.operandCoding = 487; } -x64Token x64Parser::tokenBranches6074[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6075, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6073[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6074}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6072[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6073}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6071[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6072}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6070[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6071}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6069[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6070}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6068[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6069}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6067[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6068}, {x64Token::EOT}}; -void x64Parser::TokenFunc6095(x64Operand& operand, int tokenPos) { operand.operandCoding = 489; } -x64Token x64Parser::tokenBranches6094[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6095, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6093[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6094}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6092[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6093}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6091[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6092}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6090[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6091}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6089[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6090}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6040[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6041}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6067}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6089}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6039[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6040}, {x64Token::EOT}}; -void x64Parser::TokenFunc6084(x64Operand& operand, int tokenPos) { operand.operandCoding = 488; } -x64Token x64Parser::tokenBranches6083[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6084, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6082[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6083}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6081[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6082}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6080[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6081}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6079[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6080}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6078[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6079}, {x64Token::EOT}}; -void x64Parser::TokenFunc6039(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6025[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6026}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6039, x64Parser::tokenBranches6039}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6078}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6024[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6025}, {x64Token::EOT}}; -void x64Parser::TokenFunc6108(x64Operand& operand, int tokenPos) { operand.operandCoding = 490; } -x64Token x64Parser::tokenBranches6107[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6108, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6106[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6107}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6105[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6106}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6104[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6105}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6103[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6104}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6102[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6103}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6101[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6102}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6100[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6101}, {x64Token::EOT}}; -void x64Parser::TokenFunc6134(x64Operand& operand, int tokenPos) { operand.operandCoding = 492; } -x64Token x64Parser::tokenBranches6133[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6134, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6132[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6133}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6131[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6132}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6130[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6131}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6129[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6130}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6128[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6129}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6127[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6128}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6126[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6127}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6099[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6100}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6126}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6098[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6099}, {x64Token::EOT}}; -void x64Parser::TokenFunc6121(x64Operand& operand, int tokenPos) { operand.operandCoding = 491; } -x64Token x64Parser::tokenBranches6120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6121, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6119[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6120}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6118[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6119}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6117[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6118}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6116[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6117}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6115[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6116}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6114[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6115}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6113[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6114}, {x64Token::EOT}}; -void x64Parser::TokenFunc6147(x64Operand& operand, int tokenPos) { operand.operandCoding = 493; } -x64Token x64Parser::tokenBranches6146[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6147, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6145[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6146}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6144[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6145}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6143[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6144}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6142[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6143}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6141[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6142}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6140[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6141}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6139[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6140}, {x64Token::EOT}}; -void x64Parser::TokenFunc6167(x64Operand& operand, int tokenPos) { operand.operandCoding = 495; } -x64Token x64Parser::tokenBranches6166[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6167, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6165[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6166}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6164[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6165}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6163[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6164}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6162[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6163}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6161[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6162}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6112[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6113}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6139}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6161}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6111[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6112}, {x64Token::EOT}}; -void x64Parser::TokenFunc6156(x64Operand& operand, int tokenPos) { operand.operandCoding = 494; } -x64Token x64Parser::tokenBranches6155[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6156, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6154[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6155}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6153[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6154}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6152[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6153}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6151[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6152}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6150[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6151}, {x64Token::EOT}}; -void x64Parser::TokenFunc6111(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6097[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6098}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6111, x64Parser::tokenBranches6111}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6150}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6096[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6097}, {x64Token::EOT}}; -void x64Parser::TokenFunc6180(x64Operand& operand, int tokenPos) { operand.operandCoding = 496; } -x64Token x64Parser::tokenBranches6179[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6180, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6178[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6179}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6177[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6176[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6177}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6175[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6176}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6174[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6175}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6173[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6174}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6172[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6173}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6171[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6172}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6170[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6171}, {x64Token::EOT}}; -void x64Parser::TokenFunc6193(x64Operand& operand, int tokenPos) { operand.operandCoding = 497; } -x64Token x64Parser::tokenBranches6192[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6193, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6191[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6192}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6190[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6191}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6189[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6190}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6188[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6189}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6187[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6188}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6186[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6187}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6185[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6186}, {x64Token::EOT}}; -void x64Parser::TokenFunc6213(x64Operand& operand, int tokenPos) { operand.operandCoding = 499; } -x64Token x64Parser::tokenBranches6212[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6213, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6211[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6212}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6210[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6211}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6209[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6210}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6208[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6209}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6207[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6208}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6184[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6185}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6207}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6183[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6184}, {x64Token::EOT}}; -void x64Parser::TokenFunc6202(x64Operand& operand, int tokenPos) { operand.operandCoding = 498; } -x64Token x64Parser::tokenBranches6201[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6202, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6200[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6201}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6199[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6200}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6198[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6199}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6196[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6197}, {x64Token::EOT}}; -void x64Parser::TokenFunc6183(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6169[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6170}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6183, x64Parser::tokenBranches6183}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6196}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6168[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6169}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5949[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5950}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6024}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6096}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6168}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6218(x64Operand& operand, int tokenPos) { operand.operandCoding = 500; } -x64Token x64Parser::tokenBranches6217[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6218, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6223_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6223(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6223_16; - operand.values[17] = tokenCoding6223_17; - operand.values[18] = tokenCoding6223_18; - operand.values[19] = tokenCoding6223_19; -} -Coding x64Parser::tokenCoding6227_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_19[] = { + { CODING_NAME("segm") Coding::stateFunc, 4 }, + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7261_16; + operand.values[17] = tokenCoding7261_17; + operand.values[18] = tokenCoding7261_18; + operand.values[19] = tokenCoding7261_19; +} +x64Token x64Parser::tokenBranches7260[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7261, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7259[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6227_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7283_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6227_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7283_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7283_18; + operand.values[19] = tokenCoding7283_19; +} +x64Token x64Parser::tokenBranches7282[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7283, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6227_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6227_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6227(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6227_16; - operand.values[17] = tokenCoding6227_17; - operand.values[23] = tokenCoding6227_23; - operand.values[18] = tokenCoding6227_18; - operand.values[19] = tokenCoding6227_19; -} -x64Token x64Parser::tokenBranches6222[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6223, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc6227, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6221[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6222}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6220[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6221}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6231_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6231_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6231_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7267_16; + operand.values[17] = tokenCoding7267_17; + operand.values[18] = tokenCoding7267_18; + operand.values[19] = tokenCoding7267_19; +} +x64Token x64Parser::tokenBranches7266[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7265[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6231_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6231(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6231_16; - operand.values[17] = tokenCoding6231_17; - operand.values[18] = tokenCoding6231_18; - operand.values[19] = tokenCoding6231_19; -} -x64Token x64Parser::tokenBranches6230[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6231, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6229[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6230}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6228[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6229}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6235_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7271_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6235_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7271_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7271_18; + operand.values[19] = tokenCoding7271_19; +} +x64Token x64Parser::tokenBranches7270[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7271, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7269[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7268[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) +{ + operand.values[30] = new Coding[2]; + CleanupValues.push_back(operand.values[30]); + operand.values[30]->type = Coding::reg; + operand.values[30]->val = inputTokens[tokenPos]->val->ival; + operand.values[30]->bits = 0; + operand.values[30]->field = 0; + operand.values[30]->unary = 0; + operand.values[30]->binary = 0; + operand.values[30][1].type = Coding::eot; +} +void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) +{ + operand.values[31] = new Coding[2]; + CleanupValues.push_back(operand.values[31]); + operand.values[31]->type = Coding::reg; + operand.values[31]->val = inputTokens[tokenPos]->val->ival; + operand.values[31]->bits = 0; + operand.values[31]->field = 0; + operand.values[31]->unary = 0; + operand.values[31]->binary = 0; + operand.values[31][1].type = Coding::eot; +} +void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) +{ + operand.values[32] = new Coding[2]; + CleanupValues.push_back(operand.values[32]); + operand.values[32]->type = Coding::reg; + operand.values[32]->val = inputTokens[tokenPos]->val->ival; + operand.values[32]->bits = 0; + operand.values[32]->field = 0; + operand.values[32]->unary = 0; + operand.values[32]->binary = 0; + operand.values[32][1].type = Coding::eot; +} +void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6975[] = { + {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6976, x64Parser::tokenBranches6976 }, + {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6979, x64Parser::tokenBranches6979 }, + {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7069, x64Parser::tokenBranches7069 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7077, x64Parser::tokenBranches7077 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7081, x64Parser::tokenBranches7081 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7085, x64Parser::tokenBranches7085 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7242, x64Parser::tokenBranches7242 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7297(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 606; +} +x64Token x64Parser::tokenBranches7296[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7297, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7295[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7294[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7310(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 607; +} +x64Token x64Parser::tokenBranches7309[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7310, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7308[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7307[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7293[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7307, x64Parser::tokenBranches7307 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6235_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7292[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6235_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6235(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6235_16; - operand.values[17] = tokenCoding6235_17; - operand.values[18] = tokenCoding6235_18; - operand.values[19] = tokenCoding6235_19; -} -x64Token x64Parser::tokenBranches6234[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6235, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6233[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6234}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6232[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches6233}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6239_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7291[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7290[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7289[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6239(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6239_16; - operand.values[17] = tokenCoding6239_17; - operand.values[18] = tokenCoding6239_18; - operand.values[19] = tokenCoding6239_19; -} -x64Token x64Parser::tokenBranches6238[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6239, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6237[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6238}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6236[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6237}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6219[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6220}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6228}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6232}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6236}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6241_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7323(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 608; +} +x64Token x64Parser::tokenBranches7322[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7323, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7321[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7320[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6241(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6241_16; - operand.values[17] = tokenCoding6241_17; - operand.values[18] = tokenCoding6241_18; - operand.values[19] = tokenCoding6241_19; -} -x64Token x64Parser::tokenBranches6240[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6241, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6243_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7336(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 609; +} +x64Token x64Parser::tokenBranches7335[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7336, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7334[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7333[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6243(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6243_16; - operand.values[17] = tokenCoding6243_17; - operand.values[18] = tokenCoding6243_18; - operand.values[19] = tokenCoding6243_19; -} -x64Token x64Parser::tokenBranches6242[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6243, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6246(x64Operand& operand, int tokenPos) { operand.operandCoding = 501; } -x64Token x64Parser::tokenBranches6245[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6258(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 502; - operand.values[27] = new Coding[2]; - CleanupValues.push_back(operand.values[27]); - operand.values[27]->type = Coding::number; - operand.values[27]->val = operands.size(); - operand.values[27]->bits = 0; - operand.values[27]->field = 0; - operand.values[27]->unary = 0; - operand.values[27]->binary = 0; - operand.values[27][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6257[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6258, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6256[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6255[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256}, {x64Token::EOT}}; -void x64Parser::TokenFunc6255(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6254[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc6255, x64Parser::tokenBranches6255}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6253[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6262_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7319[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7333, x64Parser::tokenBranches7333 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7318[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&'}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7317[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6262(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6262_16; - operand.values[17] = tokenCoding6262_17; - operand.values[18] = tokenCoding6262_18; - operand.values[19] = tokenCoding6262_19; -} -x64Token x64Parser::tokenBranches6261[] = {{ - x64Token::ADDRESSCLASS, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6262, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6260[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261}, {x64Token::EOT}}; -void x64Parser::TokenFunc6260(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7316[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7315[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7288[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7287[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7286[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7345(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches6259[] = { - {x64Token::NUMBER, 2, 0, 0, NULL, &x64Parser::TokenFunc6260, x64Parser::tokenBranches6260}, {x64Token::EOT}}; -void x64Parser::TokenFunc6275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6274[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6275, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6273[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6272[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6279(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6278[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6279, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6277[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6276[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6283(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6282[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6283, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6281[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6280[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6287(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6286[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6287, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6285[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6284[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6291(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6290[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6291, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6289[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6288[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6295(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6294[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6295, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6293[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6292[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6299(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6298[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6299, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6297[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6296[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6303(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6302[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6303, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6301[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6300[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6307(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6306[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6307, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6305[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6310_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7344[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7345, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7356(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 611; +} +x64Token x64Parser::tokenBranches7355[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7356, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6310(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6310_16; - operand.values[17] = tokenCoding6310_17; - operand.values[19] = tokenCoding6310_19; -} -x64Token x64Parser::tokenBranches6309[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6310, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6312_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7354[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7353[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6312(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6312_16; - operand.values[17] = tokenCoding6312_17; - operand.values[19] = tokenCoding6312_19; -} -x64Token x64Parser::tokenBranches6311[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6312, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6308(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6304[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305}, - { - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6308, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6316(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6315[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6316, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6313[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6320(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6319[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6320, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6318[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6317[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6324_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7343[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7353, x64Parser::tokenBranches7353 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7342[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6324(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6324_16; - operand.values[17] = tokenCoding6324_17; - operand.values[19] = tokenCoding6324_19; -} -x64Token x64Parser::tokenBranches6323[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6324, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6326_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7341[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7340[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6326(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6326_16; - operand.values[17] = tokenCoding6326_17; - operand.values[19] = tokenCoding6326_19; -} -x64Token x64Parser::tokenBranches6325[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6326, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6322(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6321[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6322, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6337_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7339[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6337_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6337(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6337_18; - operand.values[19] = tokenCoding6337_19; -} -x64Token x64Parser::tokenBranches6336[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6337, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6339_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7338[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6339_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6339(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6339_18; - operand.values[19] = tokenCoding6339_19; -} -x64Token x64Parser::tokenBranches6338[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6339, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6347_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7285[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7369(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 612; +} +x64Token x64Parser::tokenBranches7368[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7369, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7367[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6347(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6347_16; - operand.values[17] = tokenCoding6347_17; - operand.values[18] = tokenCoding6347_18; - operand.values[19] = tokenCoding6347_19; -} -x64Token x64Parser::tokenBranches6346[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6347, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6349_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7366[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7382(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 613; +} +x64Token x64Parser::tokenBranches7381[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7382, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7380[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6349(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6349_16; - operand.values[17] = tokenCoding6349_17; - operand.values[18] = tokenCoding6349_18; - operand.values[19] = tokenCoding6349_19; -} -x64Token x64Parser::tokenBranches6348[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6349, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6351_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7379[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7365[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7379, x64Parser::tokenBranches7379 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7364[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6351(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6351_16; - operand.values[17] = tokenCoding6351_17; - operand.values[18] = tokenCoding6351_18; - operand.values[19] = tokenCoding6351_19; -} -x64Token x64Parser::tokenBranches6350[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6351, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6345[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6359_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7363[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7362[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7361[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6359(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6359_16; - operand.values[17] = tokenCoding6359_17; - operand.values[18] = tokenCoding6359_18; - operand.values[19] = tokenCoding6359_19; -} -x64Token x64Parser::tokenBranches6358[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6359, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6361_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7395(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 614; +} +x64Token x64Parser::tokenBranches7394[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7395, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7393[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7392[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6361(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6361_16; - operand.values[17] = tokenCoding6361_17; - operand.values[18] = tokenCoding6361_18; - operand.values[19] = tokenCoding6361_19; -} -x64Token x64Parser::tokenBranches6360[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6361, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6357[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6367_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7408(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 615; +} +x64Token x64Parser::tokenBranches7407[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7408, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7406[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7405[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6367(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6367_16; - operand.values[17] = tokenCoding6367_17; - operand.values[18] = tokenCoding6367_18; - operand.values[19] = tokenCoding6367_19; -} -x64Token x64Parser::tokenBranches6366[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6367, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6369_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7391[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7405, x64Parser::tokenBranches7405 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7390[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7389[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6369(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6369_16; - operand.values[17] = tokenCoding6369_17; - operand.values[18] = tokenCoding6369_18; - operand.values[19] = tokenCoding6369_19; -} -x64Token x64Parser::tokenBranches6368[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6369, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6371_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7388[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7387[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7360[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6371(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6371_16; - operand.values[17] = tokenCoding6371_17; - operand.values[18] = tokenCoding6371_18; - operand.values[19] = tokenCoding6371_19; -} -x64Token x64Parser::tokenBranches6370[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6371, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6365_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7359[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6365_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6365(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6365_18; - operand.values[19] = tokenCoding6365_19; -} -x64Token x64Parser::tokenBranches6364[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6365, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368}, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6375_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7358[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7417(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 616; +} +x64Token x64Parser::tokenBranches7416[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7417, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7428(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 617; +} +x64Token x64Parser::tokenBranches7427[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7428, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6375(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6375_16; - operand.values[17] = tokenCoding6375_17; - operand.values[18] = tokenCoding6375_18; - operand.values[19] = tokenCoding6375_19; -} -x64Token x64Parser::tokenBranches6374[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6375, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6373[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6377_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7426[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7425[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7415[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7425, x64Parser::tokenBranches7425 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6377(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6377_16; - operand.values[17] = tokenCoding6377_17; - operand.values[18] = tokenCoding6377_18; - operand.values[19] = tokenCoding6377_19; -} -x64Token x64Parser::tokenBranches6376[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6377, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6388_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7414[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7413[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7412[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6388(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6388_16; - operand.values[17] = tokenCoding6388_17; - operand.values[18] = tokenCoding6388_18; - operand.values[19] = tokenCoding6388_19; -} -x64Token x64Parser::tokenBranches6387[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6388, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6395_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7411[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7410[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7357[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6395(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6395_16; - operand.values[17] = tokenCoding6395_17; - operand.values[18] = tokenCoding6395_18; - operand.values[19] = tokenCoding6395_19; -} -x64Token x64Parser::tokenBranches6394[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6395, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6397_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7441(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 618; +} +x64Token x64Parser::tokenBranches7440[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7441, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7439[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7438[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6397(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6397_16; - operand.values[17] = tokenCoding6397_17; - operand.values[18] = tokenCoding6397_18; - operand.values[19] = tokenCoding6397_19; -} -x64Token x64Parser::tokenBranches6396[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6397, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6406_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7454(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 619; +} +x64Token x64Parser::tokenBranches7453[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7454, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7452[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7451[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6406(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6406_16; - operand.values[17] = tokenCoding6406_17; - operand.values[18] = tokenCoding6406_18; - operand.values[19] = tokenCoding6406_19; -} -x64Token x64Parser::tokenBranches6405[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6406, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6408_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7437[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7451, x64Parser::tokenBranches7451 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7436[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7435[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6408(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6408_16; - operand.values[17] = tokenCoding6408_17; - operand.values[18] = tokenCoding6408_18; - operand.values[19] = tokenCoding6408_19; -} -x64Token x64Parser::tokenBranches6407[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6408, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6404_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7434[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6404_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6404(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6404_18; - operand.values[19] = tokenCoding6404_19; -} -x64Token x64Parser::tokenBranches6403[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6404, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6411_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7433[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7467(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 620; +} +x64Token x64Parser::tokenBranches7466[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7467, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7465[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6411(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6411_16; - operand.values[17] = tokenCoding6411_17; - operand.values[18] = tokenCoding6411_18; - operand.values[19] = tokenCoding6411_19; -} -x64Token x64Parser::tokenBranches6410[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6411, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6409[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6414_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7464[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7480(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 621; +} +x64Token x64Parser::tokenBranches7479[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7480, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7478[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6414(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6414_16; - operand.values[17] = tokenCoding6414_17; - operand.values[18] = tokenCoding6414_18; - operand.values[19] = tokenCoding6414_19; -} -x64Token x64Parser::tokenBranches6413[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6414, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6412[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6416_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7477[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7463[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7477, x64Parser::tokenBranches7477 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7462[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6416(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6416_16; - operand.values[17] = tokenCoding6416_17; - operand.values[18] = tokenCoding6416_18; - operand.values[19] = tokenCoding6416_19; -} -x64Token x64Parser::tokenBranches6415[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6416, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6418_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7461[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7460[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7459[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6418(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6418_16; - operand.values[17] = tokenCoding6418_17; - operand.values[18] = tokenCoding6418_18; - operand.values[19] = tokenCoding6418_19; -} -x64Token x64Parser::tokenBranches6417[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6418, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6422_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7432[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7431[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7430[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6422(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6422_16; - operand.values[17] = tokenCoding6422_17; - operand.values[18] = tokenCoding6422_18; - operand.values[19] = tokenCoding6422_19; -} -x64Token x64Parser::tokenBranches6421[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6422, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6424_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7489(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 622; +} +x64Token x64Parser::tokenBranches7488[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7489, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7500(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 623; +} +x64Token x64Parser::tokenBranches7499[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7500, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7498[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6424(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6424_16; - operand.values[17] = tokenCoding6424_17; - operand.values[18] = tokenCoding6424_18; - operand.values[19] = tokenCoding6424_19; -} -x64Token x64Parser::tokenBranches6423[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6424, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6426_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7497[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7487[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7497, x64Parser::tokenBranches7497 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7486[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6426(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6426_16; - operand.values[17] = tokenCoding6426_17; - operand.values[18] = tokenCoding6426_18; - operand.values[19] = tokenCoding6426_19; -} -x64Token x64Parser::tokenBranches6425[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6426, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6420_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7485[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6420_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6420(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6420_18; - operand.values[19] = tokenCoding6420_19; -} -x64Token x64Parser::tokenBranches6419[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6420, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423}, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6429_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7484[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7483[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7482[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6429(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6429_16; - operand.values[17] = tokenCoding6429_17; - operand.values[18] = tokenCoding6429_18; - operand.values[19] = tokenCoding6429_19; -} -x64Token x64Parser::tokenBranches6428[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6430(x64Operand& operand, int tokenPos) { operand.operandCoding = 503; } -x64Token x64Parser::tokenBranches6427[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428}, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6430, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6433_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7429[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7513(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 624; +} +x64Token x64Parser::tokenBranches7512[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7513, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7511[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6433(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6433_16; - operand.values[17] = tokenCoding6433_17; - operand.values[18] = tokenCoding6433_18; - operand.values[19] = tokenCoding6433_19; -} -x64Token x64Parser::tokenBranches6432[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6433, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6434(x64Operand& operand, int tokenPos) { operand.operandCoding = 504; } -x64Token x64Parser::tokenBranches6431[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432}, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6434, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6444(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6443[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6444, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6442[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6441[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6448(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6447[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6448, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6446[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6445[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6457(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6456[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6457, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6455[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6454[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6461(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6460[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6461, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6459[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6458[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6463_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7510[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7526(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 625; +} +x64Token x64Parser::tokenBranches7525[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7526, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7524[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6463(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6463_16; - operand.values[17] = tokenCoding6463_17; - operand.values[18] = tokenCoding6463_18; - operand.values[19] = tokenCoding6463_19; -} -x64Token x64Parser::tokenBranches6462[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6463, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6465_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7523[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7509[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7523, x64Parser::tokenBranches7523 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7508[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6465(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6465_16; - operand.values[17] = tokenCoding6465_17; - operand.values[18] = tokenCoding6465_18; - operand.values[19] = tokenCoding6465_19; -} -x64Token x64Parser::tokenBranches6464[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6465, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6476(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 505; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6475[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6476, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6503_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7507[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7506[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7505[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 4}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6503(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6503_16; - operand.values[17] = tokenCoding6503_17; - operand.values[18] = tokenCoding6503_18; - operand.values[19] = tokenCoding6503_19; -} -x64Token x64Parser::tokenBranches6502[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6503, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6509_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7504[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7503[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7502[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6509(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6509_16; - operand.values[17] = tokenCoding6509_17; - operand.values[18] = tokenCoding6509_18; - operand.values[19] = tokenCoding6509_19; -} -x64Token x64Parser::tokenBranches6501[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502}, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6509, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6500[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501}, {x64Token::EOT}}; -void x64Parser::TokenFunc6480(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 506; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7535(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 624; } -Coding x64Parser::tokenCoding6500_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7534[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7535, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7546(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 625; +} +x64Token x64Parser::tokenBranches7545[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7546, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7544[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7543[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6500(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6500_16; - operand.values[17] = tokenCoding6500_17; - operand.values[18] = tokenCoding6500_18; - operand.values[19] = tokenCoding6500_19; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6479[] = { - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6480, - }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL, &x64Parser::TokenFunc6500, x64Parser::tokenBranches6500}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6474[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6473[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474}, {x64Token::EOT}}; -void x64Parser::TokenFunc6484(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 507; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6483[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6484, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6520_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding6520_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7533[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7543, x64Parser::tokenBranches7543 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7532[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7531[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7530[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7529[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7528[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7501[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7284[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6520_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 5}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6520(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6520_16; - operand.values[17] = tokenCoding6520_17; - operand.values[18] = tokenCoding6520_18; - operand.values[19] = tokenCoding6520_19; -} -x64Token x64Parser::tokenBranches6519[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6520, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6526_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6526(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6526_16; - operand.values[17] = tokenCoding6526_17; - operand.values[18] = tokenCoding6526_18; - operand.values[19] = tokenCoding6526_19; -} -x64Token x64Parser::tokenBranches6518[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519}, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6526, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6517[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518}, {x64Token::EOT}}; -void x64Parser::TokenFunc6488(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 508; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7551_16; + operand.values[17] = tokenCoding7551_17; + operand.values[18] = tokenCoding7551_18; + operand.values[19] = tokenCoding7551_19; } -Coding x64Parser::tokenCoding6517_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7550[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7551, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7549[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7548[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6517(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6517_16; - operand.values[17] = tokenCoding6517_17; - operand.values[18] = tokenCoding6517_18; - operand.values[19] = tokenCoding6517_19; -} -x64Token x64Parser::tokenBranches6487[] = { - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6488, - }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL, &x64Parser::TokenFunc6517, x64Parser::tokenBranches6517}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6482[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6481[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482}, {x64Token::EOT}}; -void x64Parser::TokenFunc6492(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 509; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6491[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6492, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6537_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 6}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6537(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6537_16; - operand.values[17] = tokenCoding6537_17; - operand.values[18] = tokenCoding6537_18; - operand.values[19] = tokenCoding6537_19; -} -x64Token x64Parser::tokenBranches6536[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6537, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6543_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7555(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7555_16; + operand.values[17] = tokenCoding7555_17; + operand.values[18] = tokenCoding7555_18; + operand.values[19] = tokenCoding7555_19; +} +x64Token x64Parser::tokenBranches7554[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7555, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7553[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7552[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6543(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6543_16; - operand.values[17] = tokenCoding6543_17; - operand.values[18] = tokenCoding6543_18; - operand.values[19] = tokenCoding6543_19; -} -x64Token x64Parser::tokenBranches6535[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536}, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6543, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6534[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535}, {x64Token::EOT}}; -void x64Parser::TokenFunc6496(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 510; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding6534_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6534(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7559(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6534_16; - operand.values[17] = tokenCoding6534_17; - operand.values[18] = tokenCoding6534_18; - operand.values[19] = tokenCoding6534_19; + operand.values[16] = tokenCoding7559_16; + operand.values[17] = tokenCoding7559_17; + operand.values[18] = tokenCoding7559_18; + operand.values[19] = tokenCoding7559_19; } -x64Token x64Parser::tokenBranches6495[] = { - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6496, - }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL, &x64Parser::TokenFunc6534, x64Parser::tokenBranches6534}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6490[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6489[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6549_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7558[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7559, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7557[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7556[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6549(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6549_16; - operand.values[17] = tokenCoding6549_17; - operand.values[18] = tokenCoding6549_18; - operand.values[19] = tokenCoding6549_19; -} -x64Token x64Parser::tokenBranches6548[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6549, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6551_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6551_16; - operand.values[17] = tokenCoding6551_17; - operand.values[18] = tokenCoding6551_18; - operand.values[19] = tokenCoding6551_19; -} -x64Token x64Parser::tokenBranches6550[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6551, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6553_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7563_16; + operand.values[17] = tokenCoding7563_17; + operand.values[18] = tokenCoding7563_18; + operand.values[19] = tokenCoding7563_19; +} +x64Token x64Parser::tokenBranches7562[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7563, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7560[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6553_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6553(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6553_16; - operand.values[17] = tokenCoding6553_17; - operand.values[18] = tokenCoding6553_18; - operand.values[19] = tokenCoding6553_19; -} -x64Token x64Parser::tokenBranches6552[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6553, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6555_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7567_16; + operand.values[17] = tokenCoding7567_17; + operand.values[18] = tokenCoding7567_18; + operand.values[19] = tokenCoding7567_19; +} +x64Token x64Parser::tokenBranches7566[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7567, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7564[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6555_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7571_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6555(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6555_16; - operand.values[17] = tokenCoding6555_17; - operand.values[18] = tokenCoding6555_18; - operand.values[19] = tokenCoding6555_19; -} -x64Token x64Parser::tokenBranches6554[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6555, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6473(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc6481(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc6489(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6472[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc6473, x64Parser::tokenBranches6473}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc6481, x64Parser::tokenBranches6481}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc6489, x64Parser::tokenBranches6489}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6560(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 514; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6559[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6575(x64Operand& operand, int tokenPos) { operand.operandCoding = 518; } -x64Token x64Parser::tokenBranches6558[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6575, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6557[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558}, {x64Token::EOT}}; -void x64Parser::TokenFunc6564(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 515; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6563[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6564, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6578(x64Operand& operand, int tokenPos) { operand.operandCoding = 519; } -x64Token x64Parser::tokenBranches6562[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6578, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6561[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562}, {x64Token::EOT}}; -void x64Parser::TokenFunc6568(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 516; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6567[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6568, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6581(x64Operand& operand, int tokenPos) { operand.operandCoding = 520; } -x64Token x64Parser::tokenBranches6566[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6581, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6565[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566}, {x64Token::EOT}}; -void x64Parser::TokenFunc6572(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 517; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6571[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6584(x64Operand& operand, int tokenPos) { operand.operandCoding = 521; } -x64Token x64Parser::tokenBranches6570[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6584, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6569[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6556[] = {{x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6593(x64Operand& operand, int tokenPos) { operand.operandCoding = 522; } -x64Token x64Parser::tokenBranches6592[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6593, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6591[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6590[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591}, {x64Token::EOT}}; -void x64Parser::TokenFunc6609(x64Operand& operand, int tokenPos) { operand.operandCoding = 524; } -x64Token x64Parser::tokenBranches6608[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6609, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6607[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6606[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6589[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6588[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6587[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588}, {x64Token::EOT}}; -void x64Parser::TokenFunc6601(x64Operand& operand, int tokenPos) { operand.operandCoding = 523; } -x64Token x64Parser::tokenBranches6600[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6601, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6599[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6598[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599}, {x64Token::EOT}}; -void x64Parser::TokenFunc6617(x64Operand& operand, int tokenPos) { operand.operandCoding = 525; } -x64Token x64Parser::tokenBranches6616[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6617, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6615[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6614[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615}, {x64Token::EOT}}; -void x64Parser::TokenFunc6631(x64Operand& operand, int tokenPos) { operand.operandCoding = 527; } -x64Token x64Parser::tokenBranches6630[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6631, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6629[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6628[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6597[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6596[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597}, {x64Token::EOT}}; -void x64Parser::TokenFunc6623(x64Operand& operand, int tokenPos) { operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches6622[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6623, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6621[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6620[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621}, {x64Token::EOT}}; -void x64Parser::TokenFunc6596(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6595[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6596, x64Parser::tokenBranches6596}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6586[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6639(x64Operand& operand, int tokenPos) { operand.operandCoding = 528; } -x64Token x64Parser::tokenBranches6638[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6639, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6637[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6636[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637}, {x64Token::EOT}}; -void x64Parser::TokenFunc6655(x64Operand& operand, int tokenPos) { operand.operandCoding = 530; } -x64Token x64Parser::tokenBranches6654[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6655, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6653[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6652[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6635[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6634[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6633[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634}, {x64Token::EOT}}; -void x64Parser::TokenFunc6647(x64Operand& operand, int tokenPos) { operand.operandCoding = 529; } -x64Token x64Parser::tokenBranches6646[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6647, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6644[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645}, {x64Token::EOT}}; -void x64Parser::TokenFunc6663(x64Operand& operand, int tokenPos) { operand.operandCoding = 531; } -x64Token x64Parser::tokenBranches6662[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6663, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6661[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6660[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661}, {x64Token::EOT}}; -void x64Parser::TokenFunc6677(x64Operand& operand, int tokenPos) { operand.operandCoding = 533; } -x64Token x64Parser::tokenBranches6676[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6677, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6675[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6674[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6643[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6642[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643}, {x64Token::EOT}}; -void x64Parser::TokenFunc6669(x64Operand& operand, int tokenPos) { operand.operandCoding = 532; } -x64Token x64Parser::tokenBranches6668[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6669, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6667[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6666[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667}, {x64Token::EOT}}; -void x64Parser::TokenFunc6642(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6641[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6642, x64Parser::tokenBranches6642}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6632[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6685(x64Operand& operand, int tokenPos) { operand.operandCoding = 534; } -x64Token x64Parser::tokenBranches6684[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6685, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6683[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6682[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683}, {x64Token::EOT}}; -void x64Parser::TokenFunc6701(x64Operand& operand, int tokenPos) { operand.operandCoding = 536; } -x64Token x64Parser::tokenBranches6700[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6701, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6699[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6698[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6681[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6680[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6679[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680}, {x64Token::EOT}}; -void x64Parser::TokenFunc6693(x64Operand& operand, int tokenPos) { operand.operandCoding = 535; } -x64Token x64Parser::tokenBranches6692[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6693, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6691[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6690[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691}, {x64Token::EOT}}; -void x64Parser::TokenFunc6709(x64Operand& operand, int tokenPos) { operand.operandCoding = 537; } -x64Token x64Parser::tokenBranches6708[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6709, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6707[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6706[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707}, {x64Token::EOT}}; -void x64Parser::TokenFunc6723(x64Operand& operand, int tokenPos) { operand.operandCoding = 539; } -x64Token x64Parser::tokenBranches6722[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6723, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6721[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6720[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6689[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6688[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689}, {x64Token::EOT}}; -void x64Parser::TokenFunc6715(x64Operand& operand, int tokenPos) { operand.operandCoding = 538; } -x64Token x64Parser::tokenBranches6714[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6715, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6713[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6712[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713}, {x64Token::EOT}}; -void x64Parser::TokenFunc6688(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +Coding x64Parser::tokenCoding7571_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7571_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7571_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7571_16; + operand.values[17] = tokenCoding7571_17; + operand.values[18] = tokenCoding7571_18; + operand.values[19] = tokenCoding7571_19; +} +x64Token x64Parser::tokenBranches7570[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7571, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7568[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6687[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6688, x64Parser::tokenBranches6688}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6678[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6585[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6730(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 540; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6729[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6730, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6728[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6736_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7547[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7548, x64Parser::tokenBranches7548 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7552, x64Parser::tokenBranches7552 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7556, x64Parser::tokenBranches7556 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6736_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6736(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6736_16; - operand.values[17] = tokenCoding6736_17; - operand.values[18] = tokenCoding6736_18; - operand.values[19] = tokenCoding6736_19; -} -x64Token x64Parser::tokenBranches6735[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6736, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6740(x64Operand& operand, int tokenPos) { operand.operandCoding = 541; } -x64Token x64Parser::tokenBranches6739[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6740, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6748(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 542; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6747[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6748, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6750(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 543; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6749[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6750, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6761(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 544; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6760[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc6761, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6766(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 545; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6765[] = {{ - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6766, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6759[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6758[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6775_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6775(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6775_16; - operand.values[17] = tokenCoding6775_17; - operand.values[18] = tokenCoding6775_18; - operand.values[19] = tokenCoding6775_19; -} -x64Token x64Parser::tokenBranches6774[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6775, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6778_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7577_16; + operand.values[17] = tokenCoding7577_17; + operand.values[23] = tokenCoding7577_23; + operand.values[18] = tokenCoding7577_18; + operand.values[19] = tokenCoding7577_19; +} +x64Token x64Parser::tokenBranches7576[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7577, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6778(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6778_16; - operand.values[17] = tokenCoding6778_17; - operand.values[18] = tokenCoding6778_18; - operand.values[19] = tokenCoding6778_19; -} -x64Token x64Parser::tokenBranches6777[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6758(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::number; - operand.values[2]->val = operands.size(); - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6768(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 546; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6770(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 547; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding6772_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7580_16; + operand.values[17] = tokenCoding7580_17; + operand.values[23] = tokenCoding7580_23; + operand.values[18] = tokenCoding7580_18; + operand.values[19] = tokenCoding7580_19; +} +x64Token x64Parser::tokenBranches7579[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7580, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7578[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 626; +} +x64Token x64Parser::tokenBranches7574[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7575, x64Parser::tokenBranches7575 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7581, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6772(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6772_16; - operand.values[17] = tokenCoding6772_17; - operand.values[18] = tokenCoding6772_18; - operand.values[19] = tokenCoding6772_19; + operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches6757[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc6758, x64Parser::tokenBranches6758}, - { - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc6768, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6770, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6772, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6780(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 548; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6779[] = {{ - x64Token::NUMBER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc6780, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6782(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 549; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6784(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 550; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6781[] = {{ - x64Token::NUMBER, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc6782, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc6784, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6792_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7582[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7583, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6792_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6792(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6792_16; - operand.values[17] = tokenCoding6792_17; - operand.values[18] = tokenCoding6792_18; - operand.values[19] = tokenCoding6792_19; -} -x64Token x64Parser::tokenBranches6791[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6792, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6794_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7593_16; + operand.values[17] = tokenCoding7593_17; + operand.values[18] = tokenCoding7593_18; + operand.values[19] = tokenCoding7593_19; +} +x64Token x64Parser::tokenBranches7592[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7593, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6794_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6794(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6794_16; - operand.values[17] = tokenCoding6794_17; - operand.values[18] = tokenCoding6794_18; - operand.values[19] = tokenCoding6794_19; -} -x64Token x64Parser::tokenBranches6793[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6794, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6796_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6796(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6796_16; - operand.values[17] = tokenCoding6796_17; - operand.values[18] = tokenCoding6796_18; - operand.values[19] = tokenCoding6796_19; -} -x64Token x64Parser::tokenBranches6795[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6796, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6785(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 549; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6786(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 550; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7589_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7589_16; + operand.values[17] = tokenCoding7589_17; + operand.values[18] = tokenCoding7589_18; + operand.values[19] = tokenCoding7589_19; } -Coding x64Parser::tokenCoding6787_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7588[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7589, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6787_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7587[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6787_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7600_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7600_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7600_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7600_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6787(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6787_16; - operand.values[17] = tokenCoding6787_17; - operand.values[18] = tokenCoding6787_18; - operand.values[19] = tokenCoding6787_19; + operand.values[16] = tokenCoding7600_16; + operand.values[17] = tokenCoding7600_17; + operand.values[18] = tokenCoding7600_18; + operand.values[19] = tokenCoding7600_19; } -Coding x64Parser::tokenCoding6788_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7599[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7600, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6788_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7596_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7596_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7596_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7596_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7596(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7596_16; + operand.values[17] = tokenCoding7596_17; + operand.values[18] = tokenCoding7596_18; + operand.values[19] = tokenCoding7596_19; +} +x64Token x64Parser::tokenBranches7595[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7596, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7594[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7586[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7587, x64Parser::tokenBranches7587 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7594, x64Parser::tokenBranches7594 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7610(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 628; +} +x64Token x64Parser::tokenBranches7609[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7610, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6788_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7608[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6788(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6788_16; - operand.values[17] = tokenCoding6788_17; - operand.values[18] = tokenCoding6788_18; - operand.values[19] = tokenCoding6788_19; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding6789_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7607[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7608, x64Parser::tokenBranches7608 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 629; +} +x64Token x64Parser::tokenBranches7613[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7614, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7612[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7611[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7612, x64Parser::tokenBranches7612 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6789(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6789_16; - operand.values[17] = tokenCoding6789_17; - operand.values[18] = tokenCoding6789_18; - operand.values[19] = tokenCoding6789_19; + operand.operandCoding = 630; } -Coding x64Parser::tokenCoding6790_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7617[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7618, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7616[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7615[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7616, x64Parser::tokenBranches7616 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6790(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6790_16; - operand.values[17] = tokenCoding6790_17; - operand.values[18] = tokenCoding6790_18; - operand.values[19] = tokenCoding6790_19; -} -x64Token x64Parser::tokenBranches6756[] = {{x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757}, - {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779}, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781}, - { - x64Token::NUMBER, - 13, - 1, - 0, - NULL, - &x64Parser::TokenFunc6785, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc6786, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc6787, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6788, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc6789, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6790, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6830_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 631; +} +x64Token x64Parser::tokenBranches7621[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7622, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7620[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7619[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7620, x64Parser::tokenBranches7620 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6830(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6830_16; - operand.values[17] = tokenCoding6830_17; - operand.values[18] = tokenCoding6830_18; - operand.values[19] = tokenCoding6830_19; -} -x64Token x64Parser::tokenBranches6829[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc6830, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6837(x64Operand& operand, int tokenPos) { operand.operandCoding = 551; } -x64Token x64Parser::tokenBranches6836[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6837, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6849(x64Operand& operand, int tokenPos) { operand.operandCoding = 553; } -x64Token x64Parser::tokenBranches6848[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6849, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6835[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6834[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835}, {x64Token::EOT}}; -void x64Parser::TokenFunc6843(x64Operand& operand, int tokenPos) { operand.operandCoding = 552; } -x64Token x64Parser::tokenBranches6842[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6843, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6855(x64Operand& operand, int tokenPos) { operand.operandCoding = 554; } -x64Token x64Parser::tokenBranches6854[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6855, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6865(x64Operand& operand, int tokenPos) { operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches6864[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6865, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6841[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6840[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841}, {x64Token::EOT}}; -void x64Parser::TokenFunc6859(x64Operand& operand, int tokenPos) { operand.operandCoding = 555; } -x64Token x64Parser::tokenBranches6858[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6859, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6840(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7625(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 632; } -x64Token x64Parser::tokenBranches6833[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6840, x64Parser::tokenBranches6840}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6832[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833}, {x64Token::EOT}}; -void x64Parser::TokenFunc6871(x64Operand& operand, int tokenPos) { operand.operandCoding = 557; } -x64Token x64Parser::tokenBranches6870[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6883(x64Operand& operand, int tokenPos) { operand.operandCoding = 559; } -x64Token x64Parser::tokenBranches6882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6883, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6869[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6868[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869}, {x64Token::EOT}}; -void x64Parser::TokenFunc6877(x64Operand& operand, int tokenPos) { operand.operandCoding = 558; } -x64Token x64Parser::tokenBranches6876[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6877, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6889(x64Operand& operand, int tokenPos) { operand.operandCoding = 560; } -x64Token x64Parser::tokenBranches6888[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6889, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6899(x64Operand& operand, int tokenPos) { operand.operandCoding = 562; } -x64Token x64Parser::tokenBranches6898[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6899, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6875[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6874[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875}, {x64Token::EOT}}; -void x64Parser::TokenFunc6893(x64Operand& operand, int tokenPos) { operand.operandCoding = 561; } -x64Token x64Parser::tokenBranches6892[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6893, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6874(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 633; } -x64Token x64Parser::tokenBranches6867[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6874, x64Parser::tokenBranches6874}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6866[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867}, {x64Token::EOT}}; -void x64Parser::TokenFunc6905(x64Operand& operand, int tokenPos) { operand.operandCoding = 563; } -x64Token x64Parser::tokenBranches6904[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6905, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6917(x64Operand& operand, int tokenPos) { operand.operandCoding = 565; } -x64Token x64Parser::tokenBranches6916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6917, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6903[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6902[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903}, {x64Token::EOT}}; -void x64Parser::TokenFunc6911(x64Operand& operand, int tokenPos) { operand.operandCoding = 564; } -x64Token x64Parser::tokenBranches6910[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6911, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6923(x64Operand& operand, int tokenPos) { operand.operandCoding = 566; } -x64Token x64Parser::tokenBranches6922[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6923, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6933(x64Operand& operand, int tokenPos) { operand.operandCoding = 568; } -x64Token x64Parser::tokenBranches6932[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6933, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6909[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6908[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909}, {x64Token::EOT}}; -void x64Parser::TokenFunc6927(x64Operand& operand, int tokenPos) { operand.operandCoding = 567; } -x64Token x64Parser::tokenBranches6926[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6927, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6908(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 634; } -x64Token x64Parser::tokenBranches6901[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6908, x64Parser::tokenBranches6908}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6900[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901}, {x64Token::EOT}}; -void x64Parser::TokenFunc6939(x64Operand& operand, int tokenPos) { operand.operandCoding = 569; } -x64Token x64Parser::tokenBranches6938[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6939, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6937[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6936[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937}, {x64Token::EOT}}; -void x64Parser::TokenFunc6945(x64Operand& operand, int tokenPos) { operand.operandCoding = 570; } -x64Token x64Parser::tokenBranches6944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6955(x64Operand& operand, int tokenPos) { operand.operandCoding = 572; } -x64Token x64Parser::tokenBranches6954[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6955, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6943[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6942[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943}, {x64Token::EOT}}; -void x64Parser::TokenFunc6949(x64Operand& operand, int tokenPos) { operand.operandCoding = 571; } -x64Token x64Parser::tokenBranches6948[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6949, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6942(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches6935[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6942, x64Parser::tokenBranches6942}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6934[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6831[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6960(x64Operand& operand, int tokenPos) { operand.operandCoding = 573; } -x64Token x64Parser::tokenBranches6959[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6960, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6962(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 574; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6961[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6962, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6964(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 575; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6963[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6964, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6966(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 576; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6965[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6966, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6968(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 576; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6967[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6968, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6970(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 575; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6969[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6970, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6974_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7624[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7625, }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7628, }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7631, }, + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7634, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7623[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7606[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619 }, + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6974(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6974_16; - operand.values[17] = tokenCoding6974_17; - operand.values[18] = tokenCoding6974_18; - operand.values[19] = tokenCoding6974_19; -} -x64Token x64Parser::tokenBranches6973[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6974, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6978_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7643(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 636; +} +x64Token x64Parser::tokenBranches7642[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7643, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7659(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 638; +} +x64Token x64Parser::tokenBranches7658[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7659, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7641[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6978(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6978_16; - operand.values[17] = tokenCoding6978_17; - operand.values[18] = tokenCoding6978_18; - operand.values[19] = tokenCoding6978_19; -} -x64Token x64Parser::tokenBranches6977[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6978, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6976[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6981_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7640[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7651(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 637; +} +x64Token x64Parser::tokenBranches7650[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7651, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7667(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 639; +} +x64Token x64Parser::tokenBranches7666[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7667, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6981(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6981_16; - operand.values[17] = tokenCoding6981_17; - operand.values[18] = tokenCoding6981_18; - operand.values[19] = tokenCoding6981_19; -} -x64Token x64Parser::tokenBranches6980[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6981, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6979[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6984_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7681(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 641; +} +x64Token x64Parser::tokenBranches7680[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7681, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7649[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7648[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6984(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6984_16; - operand.values[17] = tokenCoding6984_17; - operand.values[18] = tokenCoding6984_18; - operand.values[19] = tokenCoding6984_19; -} -x64Token x64Parser::tokenBranches6983[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6984, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6982[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983}, {x64Token::EOT}}; -void x64Parser::TokenFunc6990(x64Operand& operand, int tokenPos) { operand.operandCoding = 577; } -x64Token x64Parser::tokenBranches6989[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6990, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6998(x64Operand& operand, int tokenPos) { operand.operandCoding = 578; } -x64Token x64Parser::tokenBranches6997[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6998, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7012(x64Operand& operand, int tokenPos) { operand.operandCoding = 580; } -x64Token x64Parser::tokenBranches7011[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7012, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6997(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7011(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches6996[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc6997, x64Parser::tokenBranches6997}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7011, x64Parser::tokenBranches7011}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6995[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996}, {x64Token::EOT}}; -void x64Parser::TokenFunc7004(x64Operand& operand, int tokenPos) { operand.operandCoding = 579; } -x64Token x64Parser::tokenBranches7003[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7004, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6989(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6995(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7003(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7672[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6988[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc6989, x64Parser::tokenBranches6989}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6995, x64Parser::tokenBranches6995}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7003, x64Parser::tokenBranches7003}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6987[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6986[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6985[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986}, {x64Token::EOT}}; -void x64Parser::TokenFunc7018(x64Operand& operand, int tokenPos) { operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches7017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7026(x64Operand& operand, int tokenPos) { operand.operandCoding = 582; } -x64Token x64Parser::tokenBranches7025[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7026, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7040(x64Operand& operand, int tokenPos) { operand.operandCoding = 584; } -x64Token x64Parser::tokenBranches7039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7025(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7039(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7639[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7648, x64Parser::tokenBranches7648 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7638[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7689(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7024[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7025, x64Parser::tokenBranches7025}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7039, x64Parser::tokenBranches7039}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7023[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024}, {x64Token::EOT}}; -void x64Parser::TokenFunc7032(x64Operand& operand, int tokenPos) { operand.operandCoding = 583; } -x64Token x64Parser::tokenBranches7031[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7032, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7017(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7023(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7031(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7688[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7689, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7705(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7016[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7017, x64Parser::tokenBranches7017}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7023, x64Parser::tokenBranches7023}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7031, x64Parser::tokenBranches7031}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7015[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7014[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7013[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014}, {x64Token::EOT}}; -void x64Parser::TokenFunc7046(x64Operand& operand, int tokenPos) { operand.operandCoding = 585; } -x64Token x64Parser::tokenBranches7045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7046, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7054(x64Operand& operand, int tokenPos) { operand.operandCoding = 586; } -x64Token x64Parser::tokenBranches7053[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7054, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7068(x64Operand& operand, int tokenPos) { operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches7067[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7068, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7053(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7067(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7704[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7705, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7687[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7686[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7697(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7052[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7053, x64Parser::tokenBranches7053}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7067, x64Parser::tokenBranches7067}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7051[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052}, {x64Token::EOT}}; -void x64Parser::TokenFunc7060(x64Operand& operand, int tokenPos) { operand.operandCoding = 587; } -x64Token x64Parser::tokenBranches7059[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7060, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7045(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7051(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7059(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7696[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7697, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7713(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7044[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7045, x64Parser::tokenBranches7045}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7051, x64Parser::tokenBranches7051}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7059, x64Parser::tokenBranches7059}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7043[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7042[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7041[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042}, {x64Token::EOT}}; -void x64Parser::TokenFunc7072(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 589; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7712[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7713, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7727(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 647; } -Coding x64Parser::tokenCoding7092_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7726[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7727, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7695[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7694[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7092(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7092_16; - operand.values[17] = tokenCoding7092_17; - operand.values[18] = tokenCoding7092_18; - operand.values[19] = tokenCoding7092_19; -} -x64Token x64Parser::tokenBranches7071[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7072, - }, - { - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7092, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7070[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7069[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070}, {x64Token::EOT}}; -void x64Parser::TokenFunc7076(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 590; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 646; } -Coding x64Parser::tokenCoding7096_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7718[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7685[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7694, x64Parser::tokenBranches7694 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7684[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7735(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 648; +} +x64Token x64Parser::tokenBranches7734[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7735, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7096(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7096_16; - operand.values[17] = tokenCoding7096_17; - operand.values[23] = tokenCoding7096_23; - operand.values[18] = tokenCoding7096_18; - operand.values[19] = tokenCoding7096_19; -} -x64Token x64Parser::tokenBranches7075[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7076, - }, - { - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7096, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7074[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7073[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074}, {x64Token::EOT}}; -void x64Parser::TokenFunc7080(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 591; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7751(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 650; } -Coding x64Parser::tokenCoding7100_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7750[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7751, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7733[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7732[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7100(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7100_16; - operand.values[17] = tokenCoding7100_17; - operand.values[18] = tokenCoding7100_18; - operand.values[19] = tokenCoding7100_19; -} -x64Token x64Parser::tokenBranches7079[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7080, - }, - { - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7100, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7078[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7077[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078}, {x64Token::EOT}}; -void x64Parser::TokenFunc7084(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 592; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7743(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 649; } -Coding x64Parser::tokenCoding7104_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding7104_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding7104_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7742[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7743, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7104_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7104(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7104_16; - operand.values[17] = tokenCoding7104_17; - operand.values[18] = tokenCoding7104_18; - operand.values[19] = tokenCoding7104_19; -} -x64Token x64Parser::tokenBranches7083[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7084, - }, - { - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7104, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7082[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7081[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082}, {x64Token::EOT}}; -void x64Parser::TokenFunc7088(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 593; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7759(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 651; } -Coding x64Parser::tokenCoding7108_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7758[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7759, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7773(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 653; +} +x64Token x64Parser::tokenBranches7772[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7773, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7741[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7108(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7108_16; - operand.values[17] = tokenCoding7108_17; - operand.values[18] = tokenCoding7108_18; - operand.values[19] = tokenCoding7108_19; -} -x64Token x64Parser::tokenBranches7087[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7088, - }, - { - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7108, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7086[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7085[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7113_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7740[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 652; +} +x64Token x64Parser::tokenBranches7764[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7731[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7740, x64Parser::tokenBranches7740 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7113(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7113_16; - operand.values[17] = tokenCoding7113_17; - operand.values[18] = tokenCoding7113_18; - operand.values[19] = tokenCoding7113_19; -} -x64Token x64Parser::tokenBranches7112[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7113, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7111[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7110[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7109[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7118_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7730[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7637[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7636[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7118(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7118_16; - operand.values[17] = tokenCoding7118_17; - operand.values[18] = tokenCoding7118_18; - operand.values[19] = tokenCoding7118_19; -} -x64Token x64Parser::tokenBranches7117[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7118, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7116[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7115[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7114[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7123_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7635[] = { + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7123_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7123(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7123_16; - operand.values[17] = tokenCoding7123_17; - operand.values[18] = tokenCoding7123_18; - operand.values[19] = tokenCoding7123_19; -} -x64Token x64Parser::tokenBranches7122[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7123, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7121[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7120[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7119[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7128_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7782(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7782_16; + operand.values[17] = tokenCoding7782_17; + operand.values[18] = tokenCoding7782_18; + operand.values[19] = tokenCoding7782_19; +} +x64Token x64Parser::tokenBranches7781[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7782, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7128_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7128(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7128_16; - operand.values[17] = tokenCoding7128_17; - operand.values[18] = tokenCoding7128_18; - operand.values[19] = tokenCoding7128_19; -} -x64Token x64Parser::tokenBranches7127[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7128, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7126[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7125[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7124[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7279_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7279_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7279(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7279_18; - operand.values[19] = tokenCoding7279_19; -} -x64Token x64Parser::tokenBranches7278[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7279, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7131_16[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_17[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_18[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_19[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("creg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7131(x64Operand& operand, int tokenPos) -{ - operand.values[30] = new Coding[2]; - CleanupValues.push_back(operand.values[30]); - operand.values[30]->type = Coding::reg; - operand.values[30]->val = inputTokens[tokenPos]->val->ival; - operand.values[30]->bits = 0; - operand.values[30]->field = 0; - operand.values[30]->unary = 0; - operand.values[30]->binary = 0; - operand.values[30][1].type = Coding::eot; - operand.values[16] = tokenCoding7131_16; - operand.values[17] = tokenCoding7131_17; - operand.values[18] = tokenCoding7131_18; - operand.values[19] = tokenCoding7131_19; +void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7784_16; + operand.values[17] = tokenCoding7784_17; + operand.values[18] = tokenCoding7784_18; + operand.values[19] = tokenCoding7784_19; } -Coding x64Parser::tokenCoding7134_16[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7783[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7134_17[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_18[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_19[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7134(x64Operand& operand, int tokenPos) -{ - operand.values[31] = new Coding[2]; - CleanupValues.push_back(operand.values[31]); - operand.values[31]->type = Coding::reg; - operand.values[31]->val = inputTokens[tokenPos]->val->ival; - operand.values[31]->bits = 0; - operand.values[31]->field = 0; - operand.values[31]->unary = 0; - operand.values[31]->binary = 0; - operand.values[31][1].type = Coding::eot; - operand.values[16] = tokenCoding7134_16; - operand.values[17] = tokenCoding7134_17; - operand.values[18] = tokenCoding7134_18; - operand.values[19] = tokenCoding7134_19; -} -Coding x64Parser::tokenCoding7137_16[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_17[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7786_16; + operand.values[17] = tokenCoding7786_17; + operand.values[18] = tokenCoding7786_18; + operand.values[19] = tokenCoding7786_19; +} +x64Token x64Parser::tokenBranches7785[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7786, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 654; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 655; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 656; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7787(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 657; +} +void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 658; +} +void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 659; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7777[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7778, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7779, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7780, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7787, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7788, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7789, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7137_18[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_19[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("treg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7137(x64Operand& operand, int tokenPos) -{ - operand.values[32] = new Coding[2]; - CleanupValues.push_back(operand.values[32]); - operand.values[32]->type = Coding::reg; - operand.values[32]->val = inputTokens[tokenPos]->val->ival; - operand.values[32]->bits = 0; - operand.values[32]->field = 0; - operand.values[32]->unary = 0; - operand.values[32]->binary = 0; - operand.values[32][1].type = Coding::eot; - operand.values[16] = tokenCoding7137_16; - operand.values[17] = tokenCoding7137_17; - operand.values[18] = tokenCoding7137_18; - operand.values[19] = tokenCoding7137_19; -} -Coding x64Parser::tokenCoding7264_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7264(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7264_16; - operand.values[17] = tokenCoding7264_17; - operand.values[18] = tokenCoding7264_18; - operand.values[19] = tokenCoding7264_19; -} -x64Token x64Parser::tokenBranches7130[] = {{ - x64Token::REGISTERCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc7131, - }, - { - x64Token::REGISTERCLASS, - 22, - 1, - 0, - NULL, - &x64Parser::TokenFunc7134, - }, - { - x64Token::REGISTERCLASS, - 23, - 1, - 0, - NULL, - &x64Parser::TokenFunc7137, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7264, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7129[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130}, {x64Token::EOT}}; -void x64Parser::TokenFunc7143(x64Operand& operand, int tokenPos) { operand.operandCoding = 594; } -x64Token x64Parser::tokenBranches7142[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7143, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7141[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7140[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141}, {x64Token::EOT}}; -void x64Parser::TokenFunc7151(x64Operand& operand, int tokenPos) { operand.operandCoding = 595; } -x64Token x64Parser::tokenBranches7150[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7151, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7149[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7148[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149}, {x64Token::EOT}}; -void x64Parser::TokenFunc7165(x64Operand& operand, int tokenPos) { operand.operandCoding = 597; } -x64Token x64Parser::tokenBranches7164[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7165, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7163[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7162[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163}, {x64Token::EOT}}; -void x64Parser::TokenFunc7148(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7162(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7147[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7148, x64Parser::tokenBranches7148}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7162, x64Parser::tokenBranches7162}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7146[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147}, {x64Token::EOT}}; -void x64Parser::TokenFunc7157(x64Operand& operand, int tokenPos) { operand.operandCoding = 596; } -x64Token x64Parser::tokenBranches7156[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7157, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7155[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7154[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155}, {x64Token::EOT}}; -void x64Parser::TokenFunc7140(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7146(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7154(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7799_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7799_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7799(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7799_34; + operand.values[16] = tokenCoding7799_16; + operand.values[17] = tokenCoding7799_17; + operand.values[35] = tokenCoding7799_35; + operand.values[18] = tokenCoding7799_18; + operand.values[19] = tokenCoding7799_19; } -x64Token x64Parser::tokenBranches7139[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7140, x64Parser::tokenBranches7140}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7146, x64Parser::tokenBranches7146}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7154, x64Parser::tokenBranches7154}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7225_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7798[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7799, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7225_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7225(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7225_16; - operand.values[17] = tokenCoding7225_17; - operand.values[18] = tokenCoding7225_18; - operand.values[19] = tokenCoding7225_19; -} -Coding x64Parser::tokenCoding7229_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7229(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7229_16; - operand.values[17] = tokenCoding7229_17; - operand.values[23] = tokenCoding7229_23; - operand.values[18] = tokenCoding7229_18; - operand.values[19] = tokenCoding7229_19; -} -x64Token x64Parser::tokenBranches7224[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7225, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc7229, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7223[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7138[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7171(x64Operand& operand, int tokenPos) { operand.operandCoding = 598; } -x64Token x64Parser::tokenBranches7170[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7171, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7169[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7168[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169}, {x64Token::EOT}}; -void x64Parser::TokenFunc7179(x64Operand& operand, int tokenPos) { operand.operandCoding = 599; } -x64Token x64Parser::tokenBranches7178[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7179, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7177[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7176[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177}, {x64Token::EOT}}; -void x64Parser::TokenFunc7193(x64Operand& operand, int tokenPos) { operand.operandCoding = 601; } -x64Token x64Parser::tokenBranches7192[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7193, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7191[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7190[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191}, {x64Token::EOT}}; -void x64Parser::TokenFunc7176(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7190(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7175[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7176, x64Parser::tokenBranches7176}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7190, x64Parser::tokenBranches7190}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7174[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175}, {x64Token::EOT}}; -void x64Parser::TokenFunc7185(x64Operand& operand, int tokenPos) { operand.operandCoding = 600; } -x64Token x64Parser::tokenBranches7184[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7185, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7183[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7182[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183}, {x64Token::EOT}}; -void x64Parser::TokenFunc7168(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7174(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7182(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7801(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7801_34; + operand.values[16] = tokenCoding7801_16; + operand.values[17] = tokenCoding7801_17; + operand.values[35] = tokenCoding7801_35; + operand.values[18] = tokenCoding7801_18; + operand.values[19] = tokenCoding7801_19; } -x64Token x64Parser::tokenBranches7167[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7168, x64Parser::tokenBranches7168}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7174, x64Parser::tokenBranches7174}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7182, x64Parser::tokenBranches7182}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7233_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7800[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7801, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7233_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7233(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7233_16; - operand.values[17] = tokenCoding7233_17; - operand.values[18] = tokenCoding7233_18; - operand.values[19] = tokenCoding7233_19; -} -Coding x64Parser::tokenCoding7258_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7258(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7258_16; - operand.values[17] = tokenCoding7258_17; - operand.values[18] = tokenCoding7258_18; - operand.values[19] = tokenCoding7258_19; -} -x64Token x64Parser::tokenBranches7232[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7233, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7258, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7231[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7166[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7199(x64Operand& operand, int tokenPos) { operand.operandCoding = 602; } -x64Token x64Parser::tokenBranches7198[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7199, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7196[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197}, {x64Token::EOT}}; -void x64Parser::TokenFunc7207(x64Operand& operand, int tokenPos) { operand.operandCoding = 603; } -x64Token x64Parser::tokenBranches7206[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7207, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7205[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7204[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205}, {x64Token::EOT}}; -void x64Parser::TokenFunc7221(x64Operand& operand, int tokenPos) { operand.operandCoding = 605; } -x64Token x64Parser::tokenBranches7220[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7221, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7219[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7218[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219}, {x64Token::EOT}}; -void x64Parser::TokenFunc7204(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7218(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7203[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7204, x64Parser::tokenBranches7204}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7218, x64Parser::tokenBranches7218}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7202[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203}, {x64Token::EOT}}; -void x64Parser::TokenFunc7213(x64Operand& operand, int tokenPos) { operand.operandCoding = 604; } -x64Token x64Parser::tokenBranches7212[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7213, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7211[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7212}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7210[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211}, {x64Token::EOT}}; -void x64Parser::TokenFunc7196(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7202(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7210(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7803_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7803(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7803_34; + operand.values[16] = tokenCoding7803_16; + operand.values[17] = tokenCoding7803_17; + operand.values[35] = tokenCoding7803_35; + operand.values[18] = tokenCoding7803_18; + operand.values[19] = tokenCoding7803_19; } -x64Token x64Parser::tokenBranches7195[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7196, x64Parser::tokenBranches7196}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7202, x64Parser::tokenBranches7202}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7210, x64Parser::tokenBranches7210}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7237_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7802[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7803, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7237_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7237(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7237_16; - operand.values[17] = tokenCoding7237_17; - operand.values[18] = tokenCoding7237_18; - operand.values[19] = tokenCoding7237_19; -} -x64Token x64Parser::tokenBranches7236[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7237, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7235[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7194[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7241_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7241(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7241_16; - operand.values[17] = tokenCoding7241_17; - operand.values[18] = tokenCoding7241_18; - operand.values[19] = tokenCoding7241_19; -} -x64Token x64Parser::tokenBranches7240[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7241, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7239[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7238[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7245_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7805_34; + operand.values[16] = tokenCoding7805_16; + operand.values[17] = tokenCoding7805_17; + operand.values[35] = tokenCoding7805_35; + operand.values[18] = tokenCoding7805_18; + operand.values[19] = tokenCoding7805_19; +} +x64Token x64Parser::tokenBranches7804[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7811(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 663; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7810[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 664; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7822_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7245(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7245_16; - operand.values[17] = tokenCoding7245_17; - operand.values[18] = tokenCoding7245_18; - operand.values[19] = tokenCoding7245_19; -} -x64Token x64Parser::tokenBranches7244[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7245, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7248_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 667; + operand.values[16] = tokenCoding7822_16; + operand.values[17] = tokenCoding7822_17; + operand.values[18] = tokenCoding7822_18; + operand.values[19] = tokenCoding7822_19; +} +x64Token x64Parser::tokenBranches7815[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7816, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7822, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 665; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7824_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7824_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7824_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7824_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 668; + operand.values[16] = tokenCoding7824_16; + operand.values[17] = tokenCoding7824_17; + operand.values[18] = tokenCoding7824_18; + operand.values[19] = tokenCoding7824_19; +} +x64Token x64Parser::tokenBranches7817[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7818, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7824, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 666; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7826_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7826_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7826_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7248(x64Operand& operand, int tokenPos) +Coding x64Parser::tokenCoding7826_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7826(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 668; + operand.values[16] = tokenCoding7826_16; + operand.values[17] = tokenCoding7826_17; + operand.values[18] = tokenCoding7826_18; + operand.values[19] = tokenCoding7826_19; +} +x64Token x64Parser::tokenBranches7819[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7820, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7826, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 660; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 661; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 662; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 664; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 665; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 666; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7827(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; +} +void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 670; +} +void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 671; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7806[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7807, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7808, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7809, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7812, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7813, }, + {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7814, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7827, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7828, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7829, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 672; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7844(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 673; +} +x64Token x64Parser::tokenBranches7842[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7843, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7844, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 674; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7847(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 675; +} +x64Token x64Parser::tokenBranches7845[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7846, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7847, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7861(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7248_16; - operand.values[17] = tokenCoding7248_17; - operand.values[18] = tokenCoding7248_18; - operand.values[19] = tokenCoding7248_19; + operand.operandCoding = 676; +} +x64Token x64Parser::tokenBranches7860[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7861, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 678; } -Coding x64Parser::tokenCoding7251_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7872[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7859[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7858[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7857[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 677; +} +x64Token x64Parser::tokenBranches7866[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc7251(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7251_16; - operand.values[17] = tokenCoding7251_17; - operand.values[18] = tokenCoding7251_18; - operand.values[19] = tokenCoding7251_19; + operand.operandCoding = 679; } -Coding x64Parser::tokenCoding7254_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7878[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 681; +} +x64Token x64Parser::tokenBranches7888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7865[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7254(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7254_16; - operand.values[17] = tokenCoding7254_17; - operand.values[18] = tokenCoding7254_18; - operand.values[19] = tokenCoding7254_19; -} -x64Token x64Parser::tokenBranches7243[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244}, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc7248, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7251, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc7254, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7242[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7275_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7864[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7275_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7275_18; - operand.values[19] = tokenCoding7275_19; -} -x64Token x64Parser::tokenBranches7274[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7275, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7261_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7883(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 680; +} +x64Token x64Parser::tokenBranches7882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7883, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7863[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7864, x64Parser::tokenBranches7864 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7856[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_19[] = { - {CODING_NAME("segm") Coding::stateFunc, 4}, - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7261(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7261_16; - operand.values[17] = tokenCoding7261_17; - operand.values[18] = tokenCoding7261_18; - operand.values[19] = tokenCoding7261_19; -} -x64Token x64Parser::tokenBranches7260[] = {{ - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7261, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7259[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7283_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 682; +} +x64Token x64Parser::tokenBranches7894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7283_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7283(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7283_18; - operand.values[19] = tokenCoding7283_19; -} -x64Token x64Parser::tokenBranches7282[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7283, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7267_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 684; +} +x64Token x64Parser::tokenBranches7906[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7893[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7892[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7267(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7267_16; - operand.values[17] = tokenCoding7267_17; - operand.values[18] = tokenCoding7267_18; - operand.values[19] = tokenCoding7267_19; -} -x64Token x64Parser::tokenBranches7266[] = {{ - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7267, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7265[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7271_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7891[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7271_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7271(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7271_18; - operand.values[19] = tokenCoding7271_19; -} -x64Token x64Parser::tokenBranches7270[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7271, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7269[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7268[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269}, {x64Token::EOT}}; -void x64Parser::TokenFunc6976(x64Operand& operand, int tokenPos) -{ - operand.values[30] = new Coding[2]; - CleanupValues.push_back(operand.values[30]); - operand.values[30]->type = Coding::reg; - operand.values[30]->val = inputTokens[tokenPos]->val->ival; - operand.values[30]->bits = 0; - operand.values[30]->field = 0; - operand.values[30]->unary = 0; - operand.values[30]->binary = 0; - operand.values[30][1].type = Coding::eot; -} -void x64Parser::TokenFunc6979(x64Operand& operand, int tokenPos) -{ - operand.values[31] = new Coding[2]; - CleanupValues.push_back(operand.values[31]); - operand.values[31]->type = Coding::reg; - operand.values[31]->val = inputTokens[tokenPos]->val->ival; - operand.values[31]->bits = 0; - operand.values[31]->field = 0; - operand.values[31]->unary = 0; - operand.values[31]->binary = 0; - operand.values[31][1].type = Coding::eot; -} -void x64Parser::TokenFunc6982(x64Operand& operand, int tokenPos) -{ - operand.values[32] = new Coding[2]; - CleanupValues.push_back(operand.values[32]); - operand.values[32]->type = Coding::reg; - operand.values[32]->val = inputTokens[tokenPos]->val->ival; - operand.values[32]->bits = 0; - operand.values[32]->field = 0; - operand.values[32]->unary = 0; - operand.values[32]->binary = 0; - operand.values[32][1].type = Coding::eot; -} -void x64Parser::TokenFunc7069(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7073(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7077(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7081(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7085(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7242(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6975[] = { - {x64Token::REGISTERCLASS, 21, 0, 0, NULL, &x64Parser::TokenFunc6976, x64Parser::tokenBranches6976}, - {x64Token::REGISTERCLASS, 22, 0, 0, NULL, &x64Parser::TokenFunc6979, x64Parser::tokenBranches6979}, - {x64Token::REGISTERCLASS, 23, 0, 0, NULL, &x64Parser::TokenFunc6982, x64Parser::tokenBranches6982}, - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc7069, x64Parser::tokenBranches7069}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc7073, x64Parser::tokenBranches7073}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc7077, x64Parser::tokenBranches7077}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7081, x64Parser::tokenBranches7081}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7085, x64Parser::tokenBranches7085}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7242, x64Parser::tokenBranches7242}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7297(x64Operand& operand, int tokenPos) { operand.operandCoding = 606; } -x64Token x64Parser::tokenBranches7296[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7297, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7295[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7294[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295}, {x64Token::EOT}}; -void x64Parser::TokenFunc7310(x64Operand& operand, int tokenPos) { operand.operandCoding = 607; } -x64Token x64Parser::tokenBranches7309[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7310, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7308[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7307[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308}, {x64Token::EOT}}; -void x64Parser::TokenFunc7307(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7293[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7307, x64Parser::tokenBranches7307}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7292[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7291[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7290[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7289[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290}, {x64Token::EOT}}; -void x64Parser::TokenFunc7323(x64Operand& operand, int tokenPos) { operand.operandCoding = 608; } -x64Token x64Parser::tokenBranches7322[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7323, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7321[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7320[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321}, {x64Token::EOT}}; -void x64Parser::TokenFunc7336(x64Operand& operand, int tokenPos) { operand.operandCoding = 609; } -x64Token x64Parser::tokenBranches7335[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7336, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7334[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7333[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334}, {x64Token::EOT}}; -void x64Parser::TokenFunc7333(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7319[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7333, x64Parser::tokenBranches7333}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7318[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7317[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7316[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7315[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7288[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7287[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7286[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287}, {x64Token::EOT}}; -void x64Parser::TokenFunc7345(x64Operand& operand, int tokenPos) { operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches7344[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7345, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7356(x64Operand& operand, int tokenPos) { operand.operandCoding = 611; } -x64Token x64Parser::tokenBranches7355[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7356, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7354[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7353[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354}, {x64Token::EOT}}; -void x64Parser::TokenFunc7353(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7343[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7353, x64Parser::tokenBranches7353}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7342[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7341[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7340[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7339[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7338[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7285[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7369(x64Operand& operand, int tokenPos) { operand.operandCoding = 612; } -x64Token x64Parser::tokenBranches7368[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7369, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7367[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7366[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367}, {x64Token::EOT}}; -void x64Parser::TokenFunc7382(x64Operand& operand, int tokenPos) { operand.operandCoding = 613; } -x64Token x64Parser::tokenBranches7381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7382, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7380[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7379[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380}, {x64Token::EOT}}; -void x64Parser::TokenFunc7379(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7365[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7379, x64Parser::tokenBranches7379}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7364[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7363[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7362[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7361[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362}, {x64Token::EOT}}; -void x64Parser::TokenFunc7395(x64Operand& operand, int tokenPos) { operand.operandCoding = 614; } -x64Token x64Parser::tokenBranches7394[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7395, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7393[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7392[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393}, {x64Token::EOT}}; -void x64Parser::TokenFunc7408(x64Operand& operand, int tokenPos) { operand.operandCoding = 615; } -x64Token x64Parser::tokenBranches7407[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7408, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7406[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7405[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406}, {x64Token::EOT}}; -void x64Parser::TokenFunc7405(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7391[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7405, x64Parser::tokenBranches7405}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7390[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7389[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7388[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7387[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7360[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7359[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7358[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359}, {x64Token::EOT}}; -void x64Parser::TokenFunc7417(x64Operand& operand, int tokenPos) { operand.operandCoding = 616; } -x64Token x64Parser::tokenBranches7416[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7417, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7428(x64Operand& operand, int tokenPos) { operand.operandCoding = 617; } -x64Token x64Parser::tokenBranches7427[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7428, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7426[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7425[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426}, {x64Token::EOT}}; -void x64Parser::TokenFunc7425(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7415[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7425, x64Parser::tokenBranches7425}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7414[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7413[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7412[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7411[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7410[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7357[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7441(x64Operand& operand, int tokenPos) { operand.operandCoding = 618; } -x64Token x64Parser::tokenBranches7440[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7441, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7439[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7438[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439}, {x64Token::EOT}}; -void x64Parser::TokenFunc7454(x64Operand& operand, int tokenPos) { operand.operandCoding = 619; } -x64Token x64Parser::tokenBranches7453[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7454, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7452[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7451[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452}, {x64Token::EOT}}; -void x64Parser::TokenFunc7451(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7437[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7451, x64Parser::tokenBranches7451}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7436[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7435[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7434[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7433[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434}, {x64Token::EOT}}; -void x64Parser::TokenFunc7467(x64Operand& operand, int tokenPos) { operand.operandCoding = 620; } -x64Token x64Parser::tokenBranches7466[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7467, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7465[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7464[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465}, {x64Token::EOT}}; -void x64Parser::TokenFunc7480(x64Operand& operand, int tokenPos) { operand.operandCoding = 621; } -x64Token x64Parser::tokenBranches7479[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7480, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7478[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7477[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478}, {x64Token::EOT}}; -void x64Parser::TokenFunc7477(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7463[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7477, x64Parser::tokenBranches7477}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7462[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7461[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7460[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7459[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7432[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7431[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7430[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431}, {x64Token::EOT}}; -void x64Parser::TokenFunc7489(x64Operand& operand, int tokenPos) { operand.operandCoding = 622; } -x64Token x64Parser::tokenBranches7488[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7489, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7500(x64Operand& operand, int tokenPos) { operand.operandCoding = 623; } -x64Token x64Parser::tokenBranches7499[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7500, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7498[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7497[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498}, {x64Token::EOT}}; -void x64Parser::TokenFunc7497(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7487[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7497, x64Parser::tokenBranches7497}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7486[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7485[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7484[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7483[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7482[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7429[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7513(x64Operand& operand, int tokenPos) { operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7512[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7513, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7511[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7510[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511}, {x64Token::EOT}}; -void x64Parser::TokenFunc7526(x64Operand& operand, int tokenPos) { operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7525[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7526, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7524[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7523[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524}, {x64Token::EOT}}; -void x64Parser::TokenFunc7523(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7509[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7523, x64Parser::tokenBranches7523}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7508[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7507[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7506[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7505[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7504[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7503[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7502[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503}, {x64Token::EOT}}; -void x64Parser::TokenFunc7535(x64Operand& operand, int tokenPos) { operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7534[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7535, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7546(x64Operand& operand, int tokenPos) { operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7545[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7544[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7543[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544}, {x64Token::EOT}}; -void x64Parser::TokenFunc7543(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7533[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7543, x64Parser::tokenBranches7543}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7532[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7531[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7530[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7529[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7528[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7501[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7284[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7551_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7900[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 685; +} +x64Token x64Parser::tokenBranches7912[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 687; +} +x64Token x64Parser::tokenBranches7922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7551_16; - operand.values[17] = tokenCoding7551_17; - operand.values[18] = tokenCoding7551_18; - operand.values[19] = tokenCoding7551_19; -} -x64Token x64Parser::tokenBranches7550[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7551, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7549[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7548[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7555_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7899[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7898[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 686; +} +x64Token x64Parser::tokenBranches7916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7555(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7555_16; - operand.values[17] = tokenCoding7555_17; - operand.values[18] = tokenCoding7555_18; - operand.values[19] = tokenCoding7555_19; -} -x64Token x64Parser::tokenBranches7554[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7555, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7553[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7552[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7559_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7897[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7898, x64Parser::tokenBranches7898 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7890[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 688; +} +x64Token x64Parser::tokenBranches7928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7559(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7559_16; - operand.values[17] = tokenCoding7559_17; - operand.values[18] = tokenCoding7559_18; - operand.values[19] = tokenCoding7559_19; -} -x64Token x64Parser::tokenBranches7558[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7559, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7557[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7556[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7563_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 690; +} +x64Token x64Parser::tokenBranches7940[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7927[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7926[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7563(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7563_16; - operand.values[17] = tokenCoding7563_17; - operand.values[18] = tokenCoding7563_18; - operand.values[19] = tokenCoding7563_19; -} -x64Token x64Parser::tokenBranches7562[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7563, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7561[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7560[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7567_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7925[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 689; +} +x64Token x64Parser::tokenBranches7934[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 691; +} +x64Token x64Parser::tokenBranches7946[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7567(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7567_16; - operand.values[17] = tokenCoding7567_17; - operand.values[18] = tokenCoding7567_18; - operand.values[19] = tokenCoding7567_19; -} -x64Token x64Parser::tokenBranches7566[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7567, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7565[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7564[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7571_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 693; +} +x64Token x64Parser::tokenBranches7956[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7933[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7932[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7571(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7571_16; - operand.values[17] = tokenCoding7571_17; - operand.values[18] = tokenCoding7571_18; - operand.values[19] = tokenCoding7571_19; -} -x64Token x64Parser::tokenBranches7570[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7571, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7569[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7568[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7548(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7552(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7556(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7951(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7547[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc7548, x64Parser::tokenBranches7548}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7552, x64Parser::tokenBranches7552}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7556, x64Parser::tokenBranches7556}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7577_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7950[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7951, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7931[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7932, x64Parser::tokenBranches7932 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7924[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 694; +} +x64Token x64Parser::tokenBranches7962[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7577(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7577_16; - operand.values[17] = tokenCoding7577_17; - operand.values[23] = tokenCoding7577_23; - operand.values[18] = tokenCoding7577_18; - operand.values[19] = tokenCoding7577_19; -} -x64Token x64Parser::tokenBranches7576[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc7577, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7575[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7580_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7961[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7960[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7959[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 695; +} +x64Token x64Parser::tokenBranches7968[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7580(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7580_16; - operand.values[17] = tokenCoding7580_17; - operand.values[23] = tokenCoding7580_23; - operand.values[18] = tokenCoding7580_18; - operand.values[19] = tokenCoding7580_19; -} -x64Token x64Parser::tokenBranches7579[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc7580, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7578[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579}, {x64Token::EOT}}; -void x64Parser::TokenFunc7575(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7581(x64Operand& operand, int tokenPos) { operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7574[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc7575, x64Parser::tokenBranches7575}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7581, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7583(x64Operand& operand, int tokenPos) { operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches7582[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7583, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7593_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 695; +} +x64Token x64Parser::tokenBranches7978[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7967[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7966[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7593(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7593_16; - operand.values[17] = tokenCoding7593_17; - operand.values[18] = tokenCoding7593_18; - operand.values[19] = tokenCoding7593_19; -} -x64Token x64Parser::tokenBranches7592[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7593, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7589_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7973(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 694; +} +x64Token x64Parser::tokenBranches7972[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7973, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7965[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7966, x64Parser::tokenBranches7966 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7958[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7589(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7589_16; - operand.values[17] = tokenCoding7589_17; - operand.values[18] = tokenCoding7589_18; - operand.values[19] = tokenCoding7589_19; -} -x64Token x64Parser::tokenBranches7588[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7589, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7587[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7600_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7855[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7984(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 696; +} +x64Token x64Parser::tokenBranches7983[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7984, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7600(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7600_16; - operand.values[17] = tokenCoding7600_17; - operand.values[18] = tokenCoding7600_18; - operand.values[19] = tokenCoding7600_19; -} -x64Token x64Parser::tokenBranches7599[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7600, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7596_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_19[] = { + { CODING_NAME("reg") Coding::stateFunc, 4 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7596(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7596_16; - operand.values[17] = tokenCoding7596_17; - operand.values[18] = tokenCoding7596_18; - operand.values[19] = tokenCoding7596_19; -} -x64Token x64Parser::tokenBranches7595[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7596, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7594[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595}, {x64Token::EOT}}; -void x64Parser::TokenFunc7587(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7594(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7586[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7587, x64Parser::tokenBranches7587}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7594, x64Parser::tokenBranches7594}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7610(x64Operand& operand, int tokenPos) { operand.operandCoding = 628; } -x64Token x64Parser::tokenBranches7609[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7610, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7608[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609}, {x64Token::EOT}}; -void x64Parser::TokenFunc7608(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7607[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7608, x64Parser::tokenBranches7608}, {x64Token::EOT}}; -void x64Parser::TokenFunc7614(x64Operand& operand, int tokenPos) { operand.operandCoding = 629; } -x64Token x64Parser::tokenBranches7613[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7614, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7612[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613}, {x64Token::EOT}}; -void x64Parser::TokenFunc7612(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7611[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7612, x64Parser::tokenBranches7612}, {x64Token::EOT}}; -void x64Parser::TokenFunc7618(x64Operand& operand, int tokenPos) { operand.operandCoding = 630; } -x64Token x64Parser::tokenBranches7617[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7618, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7616[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617}, {x64Token::EOT}}; -void x64Parser::TokenFunc7616(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7615[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7616, x64Parser::tokenBranches7616}, {x64Token::EOT}}; -void x64Parser::TokenFunc7622(x64Operand& operand, int tokenPos) { operand.operandCoding = 631; } -x64Token x64Parser::tokenBranches7621[] = {{ - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7622, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7620[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621}, {x64Token::EOT}}; -void x64Parser::TokenFunc7620(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7619[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7620, x64Parser::tokenBranches7620}, {x64Token::EOT}}; -void x64Parser::TokenFunc7625(x64Operand& operand, int tokenPos) { operand.operandCoding = 632; } -void x64Parser::TokenFunc7628(x64Operand& operand, int tokenPos) { operand.operandCoding = 633; } -void x64Parser::TokenFunc7631(x64Operand& operand, int tokenPos) { operand.operandCoding = 634; } -void x64Parser::TokenFunc7634(x64Operand& operand, int tokenPos) { operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches7624[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7625, - }, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7628, - }, - { - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7631, - }, - { - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7634, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7623[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7606[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619}, - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7643(x64Operand& operand, int tokenPos) { operand.operandCoding = 636; } -x64Token x64Parser::tokenBranches7642[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7643, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7659(x64Operand& operand, int tokenPos) { operand.operandCoding = 638; } -x64Token x64Parser::tokenBranches7658[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7659, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7641[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7640[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641}, {x64Token::EOT}}; -void x64Parser::TokenFunc7651(x64Operand& operand, int tokenPos) { operand.operandCoding = 637; } -x64Token x64Parser::tokenBranches7650[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7651, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7667(x64Operand& operand, int tokenPos) { operand.operandCoding = 639; } -x64Token x64Parser::tokenBranches7666[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7667, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7681(x64Operand& operand, int tokenPos) { operand.operandCoding = 641; } -x64Token x64Parser::tokenBranches7680[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7681, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7649[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7648[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649}, {x64Token::EOT}}; -void x64Parser::TokenFunc7673(x64Operand& operand, int tokenPos) { operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches7672[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7673, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7648(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc8024(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8024_16; + operand.values[17] = tokenCoding8024_17; + operand.values[18] = tokenCoding8024_18; + operand.values[19] = tokenCoding8024_19; } -x64Token x64Parser::tokenBranches7639[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7648, x64Parser::tokenBranches7648}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7638[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639}, {x64Token::EOT}}; -void x64Parser::TokenFunc7689(x64Operand& operand, int tokenPos) { operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7688[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7689, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7705(x64Operand& operand, int tokenPos) { operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7704[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7705, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7687[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7686[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687}, {x64Token::EOT}}; -void x64Parser::TokenFunc7697(x64Operand& operand, int tokenPos) { operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7696[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7697, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7713(x64Operand& operand, int tokenPos) { operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7712[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7713, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7727(x64Operand& operand, int tokenPos) { operand.operandCoding = 647; } -x64Token x64Parser::tokenBranches7726[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7727, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7695[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7694[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695}, {x64Token::EOT}}; -void x64Parser::TokenFunc7719(x64Operand& operand, int tokenPos) { operand.operandCoding = 646; } -x64Token x64Parser::tokenBranches7718[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7719, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7694(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8023[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8024, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8034(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches7685[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7694, x64Parser::tokenBranches7694}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7684[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685}, {x64Token::EOT}}; -void x64Parser::TokenFunc7735(x64Operand& operand, int tokenPos) { operand.operandCoding = 648; } -x64Token x64Parser::tokenBranches7734[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7735, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7751(x64Operand& operand, int tokenPos) { operand.operandCoding = 650; } -x64Token x64Parser::tokenBranches7750[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7751, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7733[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7732[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733}, {x64Token::EOT}}; -void x64Parser::TokenFunc7743(x64Operand& operand, int tokenPos) { operand.operandCoding = 649; } -x64Token x64Parser::tokenBranches7742[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7743, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7759(x64Operand& operand, int tokenPos) { operand.operandCoding = 651; } -x64Token x64Parser::tokenBranches7758[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7759, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7773(x64Operand& operand, int tokenPos) { operand.operandCoding = 653; } -x64Token x64Parser::tokenBranches7772[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7773, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7741[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7740[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741}, {x64Token::EOT}}; -void x64Parser::TokenFunc7765(x64Operand& operand, int tokenPos) { operand.operandCoding = 652; } -x64Token x64Parser::tokenBranches7764[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7765, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7740(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8033[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8034, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches7731[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7740, x64Parser::tokenBranches7740}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7730[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7637[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7636[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7635[] = {{x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7782_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8032[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8031[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7782(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7782_16; - operand.values[17] = tokenCoding7782_17; - operand.values[18] = tokenCoding7782_18; - operand.values[19] = tokenCoding7782_19; -} -x64Token x64Parser::tokenBranches7781[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7782, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7784_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8030[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 698; +} +x64Token x64Parser::tokenBranches8039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 700; +} +x64Token x64Parser::tokenBranches8051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7784(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7784_16; - operand.values[17] = tokenCoding7784_17; - operand.values[18] = tokenCoding7784_18; - operand.values[19] = tokenCoding7784_19; -} -x64Token x64Parser::tokenBranches7783[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7784, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7786_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 702; +} +x64Token x64Parser::tokenBranches8061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8038[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8037[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7786(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7786_16; - operand.values[17] = tokenCoding7786_17; - operand.values[18] = tokenCoding7786_18; - operand.values[19] = tokenCoding7786_19; -} -x64Token x64Parser::tokenBranches7785[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7786, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7778(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 654; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7779(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 655; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7780(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 656; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7787(x64Operand& operand, int tokenPos) { operand.operandCoding = 657; } -void x64Parser::TokenFunc7788(x64Operand& operand, int tokenPos) { operand.operandCoding = 658; } -void x64Parser::TokenFunc7789(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 659; - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7777[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7778, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7779, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7780, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785}, - { - x64Token::REGISTER, - 97, - 1, - 0, - NULL, - &x64Parser::TokenFunc7787, - }, - { - x64Token::REGISTER, - 98, - 1, - 0, - NULL, - &x64Parser::TokenFunc7788, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7789, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7799_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8056(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 701; +} +x64Token x64Parser::tokenBranches8055[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8056, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8036[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8037, x64Parser::tokenBranches8037 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8029[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 703; +} +x64Token x64Parser::tokenBranches8067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 705; +} +x64Token x64Parser::tokenBranches8079[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7799(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7799_34; - operand.values[16] = tokenCoding7799_16; - operand.values[17] = tokenCoding7799_17; - operand.values[35] = tokenCoding7799_35; - operand.values[18] = tokenCoding7799_18; - operand.values[19] = tokenCoding7799_19; -} -x64Token x64Parser::tokenBranches7798[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7799, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7801_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8066[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8065[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8064[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 704; +} +x64Token x64Parser::tokenBranches8073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 706; +} +x64Token x64Parser::tokenBranches8085[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7801(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7801_34; - operand.values[16] = tokenCoding7801_16; - operand.values[17] = tokenCoding7801_17; - operand.values[35] = tokenCoding7801_35; - operand.values[18] = tokenCoding7801_18; - operand.values[19] = tokenCoding7801_19; -} -x64Token x64Parser::tokenBranches7800[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7801, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7803_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 708; +} +x64Token x64Parser::tokenBranches8095[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8072[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8071[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8090(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 707; +} +x64Token x64Parser::tokenBranches8089[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8090, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8070[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8071, x64Parser::tokenBranches8071 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7803(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7803_34; - operand.values[16] = tokenCoding7803_16; - operand.values[17] = tokenCoding7803_17; - operand.values[35] = tokenCoding7803_35; - operand.values[18] = tokenCoding7803_18; - operand.values[19] = tokenCoding7803_19; -} -x64Token x64Parser::tokenBranches7802[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7803, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7805_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8063[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 709; +} +x64Token x64Parser::tokenBranches8101[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 711; +} +x64Token x64Parser::tokenBranches8113[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8100[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8099[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7805(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7805_34; - operand.values[16] = tokenCoding7805_16; - operand.values[17] = tokenCoding7805_17; - operand.values[35] = tokenCoding7805_35; - operand.values[18] = tokenCoding7805_18; - operand.values[19] = tokenCoding7805_19; -} -x64Token x64Parser::tokenBranches7804[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7805, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7811(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 663; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7810[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7811, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7816(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 664; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches8098[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 710; } -Coding x64Parser::tokenCoding7822_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 712; +} +x64Token x64Parser::tokenBranches8119[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 714; +} +x64Token x64Parser::tokenBranches8129[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8105[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7822(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 667; - operand.values[16] = tokenCoding7822_16; - operand.values[17] = tokenCoding7822_17; - operand.values[18] = tokenCoding7822_18; - operand.values[19] = tokenCoding7822_19; -} -x64Token x64Parser::tokenBranches7815[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7816, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7822, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7818(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 665; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc8124(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 713; } -Coding x64Parser::tokenCoding7824_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8123[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8124, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8104[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8105, x64Parser::tokenBranches8105 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8097[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7824(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 668; - operand.values[16] = tokenCoding7824_16; - operand.values[17] = tokenCoding7824_17; - operand.values[18] = tokenCoding7824_18; - operand.values[19] = tokenCoding7824_19; -} -x64Token x64Parser::tokenBranches7817[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7818, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7824, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7820(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 666; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 715; } -Coding x64Parser::tokenCoding7826_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8135[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8134[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8133[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7826(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 668; - operand.values[16] = tokenCoding7826_16; - operand.values[17] = tokenCoding7826_17; - operand.values[18] = tokenCoding7826_18; - operand.values[19] = tokenCoding7826_19; -} -x64Token x64Parser::tokenBranches7819[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7820, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7826, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7807(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 660; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7808(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 661; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7809(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 662; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7812(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 664; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7813(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 665; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7814(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 666; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7827(x64Operand& operand, int tokenPos) { operand.operandCoding = 669; } -void x64Parser::TokenFunc7828(x64Operand& operand, int tokenPos) { operand.operandCoding = 670; } -void x64Parser::TokenFunc7829(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 671; - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7806[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7807, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7808, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7809, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810}, - { - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc7812, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7813, - }, - { - x64Token::NUMBER, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc7814, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819}, - { - x64Token::REGISTER, - 97, - 1, - 0, - NULL, - &x64Parser::TokenFunc7827, - }, - { - x64Token::REGISTER, - 98, - 1, - 0, - NULL, - &x64Parser::TokenFunc7828, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7829, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7843(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 672; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7844(x64Operand& operand, int tokenPos) { operand.operandCoding = 673; } -x64Token x64Parser::tokenBranches7842[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7843, - }, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7844, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7846(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 674; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7847(x64Operand& operand, int tokenPos) { operand.operandCoding = 675; } -x64Token x64Parser::tokenBranches7845[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7846, - }, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7847, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7861(x64Operand& operand, int tokenPos) { operand.operandCoding = 676; } -x64Token x64Parser::tokenBranches7860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7873(x64Operand& operand, int tokenPos) { operand.operandCoding = 678; } -x64Token x64Parser::tokenBranches7872[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7873, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7859[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7858[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7857[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858}, {x64Token::EOT}}; -void x64Parser::TokenFunc7867(x64Operand& operand, int tokenPos) { operand.operandCoding = 677; } -x64Token x64Parser::tokenBranches7866[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7867, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7879(x64Operand& operand, int tokenPos) { operand.operandCoding = 679; } -x64Token x64Parser::tokenBranches7878[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7879, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7889(x64Operand& operand, int tokenPos) { operand.operandCoding = 681; } -x64Token x64Parser::tokenBranches7888[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7889, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7865[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7864[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865}, {x64Token::EOT}}; -void x64Parser::TokenFunc7883(x64Operand& operand, int tokenPos) { operand.operandCoding = 680; } -x64Token x64Parser::tokenBranches7882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7883, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7864(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7863[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7864, x64Parser::tokenBranches7864}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7856[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7895(x64Operand& operand, int tokenPos) { operand.operandCoding = 682; } -x64Token x64Parser::tokenBranches7894[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7895, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7907(x64Operand& operand, int tokenPos) { operand.operandCoding = 684; } -x64Token x64Parser::tokenBranches7906[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7907, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7893[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7892[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7891[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892}, {x64Token::EOT}}; -void x64Parser::TokenFunc7901(x64Operand& operand, int tokenPos) { operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7901, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7913(x64Operand& operand, int tokenPos) { operand.operandCoding = 685; } -x64Token x64Parser::tokenBranches7912[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7913, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7923(x64Operand& operand, int tokenPos) { operand.operandCoding = 687; } -x64Token x64Parser::tokenBranches7922[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7923, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7899[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7898[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899}, {x64Token::EOT}}; -void x64Parser::TokenFunc7917(x64Operand& operand, int tokenPos) { operand.operandCoding = 686; } -x64Token x64Parser::tokenBranches7916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7917, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7898(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7897[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7898, x64Parser::tokenBranches7898}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7890[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7929(x64Operand& operand, int tokenPos) { operand.operandCoding = 688; } -x64Token x64Parser::tokenBranches7928[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7929, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7941(x64Operand& operand, int tokenPos) { operand.operandCoding = 690; } -x64Token x64Parser::tokenBranches7940[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7941, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7927[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7926[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7925[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926}, {x64Token::EOT}}; -void x64Parser::TokenFunc7935(x64Operand& operand, int tokenPos) { operand.operandCoding = 689; } -x64Token x64Parser::tokenBranches7934[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7935, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7947(x64Operand& operand, int tokenPos) { operand.operandCoding = 691; } -x64Token x64Parser::tokenBranches7946[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7947, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7957(x64Operand& operand, int tokenPos) { operand.operandCoding = 693; } -x64Token x64Parser::tokenBranches7956[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7957, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7933[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7932[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933}, {x64Token::EOT}}; -void x64Parser::TokenFunc7951(x64Operand& operand, int tokenPos) { operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7950[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7951, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7932(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8132[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches7931[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7932, x64Parser::tokenBranches7932}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7924[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7963(x64Operand& operand, int tokenPos) { operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7962[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7963, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7961[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7960[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7959[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960}, {x64Token::EOT}}; -void x64Parser::TokenFunc7969(x64Operand& operand, int tokenPos) { operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7968[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7969, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7979(x64Operand& operand, int tokenPos) { operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7978[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7979, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7967[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7966[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967}, {x64Token::EOT}}; -void x64Parser::TokenFunc7973(x64Operand& operand, int tokenPos) { operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7972[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7973, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7966(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8141[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches7965[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7966, x64Parser::tokenBranches7966}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7958[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7855[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7984(x64Operand& operand, int tokenPos) { operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7983[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7984, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding8024_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8151[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8140[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8139[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 4}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8024(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8024_16; - operand.values[17] = tokenCoding8024_17; - operand.values[18] = tokenCoding8024_18; - operand.values[19] = tokenCoding8024_19; -} -x64Token x64Parser::tokenBranches8023[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8024, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8034(x64Operand& operand, int tokenPos) { operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches8033[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8034, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8046(x64Operand& operand, int tokenPos) { operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches8045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8046, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8032[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8031[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8030[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031}, {x64Token::EOT}}; -void x64Parser::TokenFunc8040(x64Operand& operand, int tokenPos) { operand.operandCoding = 698; } -x64Token x64Parser::tokenBranches8039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8052(x64Operand& operand, int tokenPos) { operand.operandCoding = 700; } -x64Token x64Parser::tokenBranches8051[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8052, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8062(x64Operand& operand, int tokenPos) { operand.operandCoding = 702; } -x64Token x64Parser::tokenBranches8061[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8062, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8038[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8037[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038}, {x64Token::EOT}}; -void x64Parser::TokenFunc8056(x64Operand& operand, int tokenPos) { operand.operandCoding = 701; } -x64Token x64Parser::tokenBranches8055[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8056, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8037(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8036[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8037, x64Parser::tokenBranches8037}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8029[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8068(x64Operand& operand, int tokenPos) { operand.operandCoding = 703; } -x64Token x64Parser::tokenBranches8067[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8068, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8080(x64Operand& operand, int tokenPos) { operand.operandCoding = 705; } -x64Token x64Parser::tokenBranches8079[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8080, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8066[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8065[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8064[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065}, {x64Token::EOT}}; -void x64Parser::TokenFunc8074(x64Operand& operand, int tokenPos) { operand.operandCoding = 704; } -x64Token x64Parser::tokenBranches8073[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8074, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8086(x64Operand& operand, int tokenPos) { operand.operandCoding = 706; } -x64Token x64Parser::tokenBranches8085[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8086, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8096(x64Operand& operand, int tokenPos) { operand.operandCoding = 708; } -x64Token x64Parser::tokenBranches8095[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8096, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8072[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8071[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072}, {x64Token::EOT}}; -void x64Parser::TokenFunc8090(x64Operand& operand, int tokenPos) { operand.operandCoding = 707; } -x64Token x64Parser::tokenBranches8089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8071(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8070[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8071, x64Parser::tokenBranches8071}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8063[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8102(x64Operand& operand, int tokenPos) { operand.operandCoding = 709; } -x64Token x64Parser::tokenBranches8101[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8114(x64Operand& operand, int tokenPos) { operand.operandCoding = 711; } -x64Token x64Parser::tokenBranches8113[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8114, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8100[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8099[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8098[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099}, {x64Token::EOT}}; -void x64Parser::TokenFunc8108(x64Operand& operand, int tokenPos) { operand.operandCoding = 710; } -x64Token x64Parser::tokenBranches8107[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8108, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8120(x64Operand& operand, int tokenPos) { operand.operandCoding = 712; } -x64Token x64Parser::tokenBranches8119[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8120, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8130(x64Operand& operand, int tokenPos) { operand.operandCoding = 714; } -x64Token x64Parser::tokenBranches8129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8130, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8106[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8105[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106}, {x64Token::EOT}}; -void x64Parser::TokenFunc8124(x64Operand& operand, int tokenPos) { operand.operandCoding = 713; } -x64Token x64Parser::tokenBranches8123[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8124, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8105(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc8146(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8104[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8105, x64Parser::tokenBranches8105}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8097[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8136(x64Operand& operand, int tokenPos) { operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8135[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8136, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8134[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8133[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8132[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133}, {x64Token::EOT}}; -void x64Parser::TokenFunc8142(x64Operand& operand, int tokenPos) { operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8141[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8142, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8152(x64Operand& operand, int tokenPos) { operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8151[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8152, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8140[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8139[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140}, {x64Token::EOT}}; -void x64Parser::TokenFunc8146(x64Operand& operand, int tokenPos) { operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8139(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8145[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8138[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8139, x64Parser::tokenBranches8139}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8131[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8028[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8157(x64Operand& operand, int tokenPos) { operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8156[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc8157, - }, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8139, x64Parser::tokenBranches8139 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8131[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8028[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8157(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 717; +} +x64Token x64Parser::tokenBranches8156[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8157, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8159_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 4}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") Coding::stateFunc, 4 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8159(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8159(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8159_16; - operand.values[17] = tokenCoding8159_17; - operand.values[18] = tokenCoding8159_18; - operand.values[19] = tokenCoding8159_19; + operand.values[16] = tokenCoding8159_16; + operand.values[17] = tokenCoding8159_17; + operand.values[18] = tokenCoding8159_18; + operand.values[19] = tokenCoding8159_19; } Coding x64Parser::tokenCoding8160_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 5}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") Coding::stateFunc, 5 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8160(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8160(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8160_16; - operand.values[17] = tokenCoding8160_17; - operand.values[18] = tokenCoding8160_18; - operand.values[19] = tokenCoding8160_19; + operand.values[16] = tokenCoding8160_16; + operand.values[17] = tokenCoding8160_17; + operand.values[18] = tokenCoding8160_18; + operand.values[19] = tokenCoding8160_19; } Coding x64Parser::tokenCoding8161_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 6}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8161(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8161_16; - operand.values[17] = tokenCoding8161_17; - operand.values[18] = tokenCoding8161_18; - operand.values[19] = tokenCoding8161_19; -} -x64Token x64Parser::tokenBranches8158[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8159, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc8160, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc8161, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8171(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 718; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8170[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8171, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8169[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8168[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169}, {x64Token::EOT}}; -void x64Parser::TokenFunc8175(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 719; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8174[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8175, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8173[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8172[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173}, {x64Token::EOT}}; -void x64Parser::TokenFunc8179(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 720; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8178[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8179, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8177[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8176[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177}, {x64Token::EOT}}; -void x64Parser::TokenFunc8183(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 721; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8182[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8183, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8181[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8180[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181}, {x64Token::EOT}}; + { CODING_NAME("reg") Coding::stateFunc, 6 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8161(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8161_16; + operand.values[17] = tokenCoding8161_17; + operand.values[18] = tokenCoding8161_18; + operand.values[19] = tokenCoding8161_19; +} +x64Token x64Parser::tokenBranches8158[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8159, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8160, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8161, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 718; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8170[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8171, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8169[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8168[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 719; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8174[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8175, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8173[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8172[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 720; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8178[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8179, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8177[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8176[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 721; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8182[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8183, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8181[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8180[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8187_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8187(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8187_16; - operand.values[17] = tokenCoding8187_17; - operand.values[18] = tokenCoding8187_18; - operand.values[19] = tokenCoding8187_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8187_16; + operand.values[17] = tokenCoding8187_17; + operand.values[18] = tokenCoding8187_18; + operand.values[19] = tokenCoding8187_19; } Coding x64Parser::tokenCoding8191_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8191(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8191_16; - operand.values[17] = tokenCoding8191_17; - operand.values[23] = tokenCoding8191_23; - operand.values[18] = tokenCoding8191_18; - operand.values[19] = tokenCoding8191_19; -} -x64Token x64Parser::tokenBranches8186[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8187, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8191, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8185[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8184[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8191_16; + operand.values[17] = tokenCoding8191_17; + operand.values[23] = tokenCoding8191_23; + operand.values[18] = tokenCoding8191_18; + operand.values[19] = tokenCoding8191_19; +} +x64Token x64Parser::tokenBranches8186[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8187, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8191, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8185[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8184[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8195_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8195(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8195_16; - operand.values[17] = tokenCoding8195_17; - operand.values[18] = tokenCoding8195_18; - operand.values[19] = tokenCoding8195_19; -} -x64Token x64Parser::tokenBranches8194[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8195, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8193[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8192[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8195_16; + operand.values[17] = tokenCoding8195_17; + operand.values[18] = tokenCoding8195_18; + operand.values[19] = tokenCoding8195_19; +} +x64Token x64Parser::tokenBranches8194[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8195, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8193[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8192[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8199_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8199(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8199_16; - operand.values[17] = tokenCoding8199_17; - operand.values[18] = tokenCoding8199_18; - operand.values[19] = tokenCoding8199_19; -} -x64Token x64Parser::tokenBranches8198[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8199, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8196[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8199_16; + operand.values[17] = tokenCoding8199_17; + operand.values[18] = tokenCoding8199_18; + operand.values[19] = tokenCoding8199_19; +} +x64Token x64Parser::tokenBranches8198[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8199, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8196[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8203_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8203(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8203_16; - operand.values[17] = tokenCoding8203_17; - operand.values[18] = tokenCoding8203_18; - operand.values[19] = tokenCoding8203_19; -} -x64Token x64Parser::tokenBranches8202[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8203, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8201[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8200[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8203_16; + operand.values[17] = tokenCoding8203_17; + operand.values[18] = tokenCoding8203_18; + operand.values[19] = tokenCoding8203_19; +} +x64Token x64Parser::tokenBranches8202[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8203, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8201[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8200[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8248_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8248(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8248_16; - operand.values[17] = tokenCoding8248_17; - operand.values[18] = tokenCoding8248_18; - operand.values[19] = tokenCoding8248_19; -} -x64Token x64Parser::tokenBranches8247[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8248, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8248_16; + operand.values[17] = tokenCoding8248_17; + operand.values[18] = tokenCoding8248_18; + operand.values[19] = tokenCoding8248_19; +} +x64Token x64Parser::tokenBranches8247[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8248, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8206_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8206(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8206_16; - operand.values[17] = tokenCoding8206_17; - operand.values[18] = tokenCoding8206_18; - operand.values[19] = tokenCoding8206_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8206_16; + operand.values[17] = tokenCoding8206_17; + operand.values[18] = tokenCoding8206_18; + operand.values[19] = tokenCoding8206_19; } Coding x64Parser::tokenCoding8212_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8212(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8212_16; - operand.values[17] = tokenCoding8212_17; - operand.values[23] = tokenCoding8212_23; - operand.values[18] = tokenCoding8212_18; - operand.values[19] = tokenCoding8212_19; -} -x64Token x64Parser::tokenBranches8205[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8206, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8212, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8204[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8212_16; + operand.values[17] = tokenCoding8212_17; + operand.values[23] = tokenCoding8212_23; + operand.values[18] = tokenCoding8212_18; + operand.values[19] = tokenCoding8212_19; +} +x64Token x64Parser::tokenBranches8205[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8206, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8212, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8204[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8209_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8209(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8209_16; - operand.values[17] = tokenCoding8209_17; - operand.values[23] = tokenCoding8209_23; - operand.values[18] = tokenCoding8209_18; - operand.values[19] = tokenCoding8209_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8209_16; + operand.values[17] = tokenCoding8209_17; + operand.values[23] = tokenCoding8209_23; + operand.values[18] = tokenCoding8209_18; + operand.values[19] = tokenCoding8209_19; } Coding x64Parser::tokenCoding8215_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8215(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8215_16; - operand.values[17] = tokenCoding8215_17; - operand.values[23] = tokenCoding8215_23; - operand.values[18] = tokenCoding8215_18; - operand.values[19] = tokenCoding8215_19; -} -x64Token x64Parser::tokenBranches8208[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8209, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8215, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8207[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8215_16; + operand.values[17] = tokenCoding8215_17; + operand.values[23] = tokenCoding8215_23; + operand.values[18] = tokenCoding8215_18; + operand.values[19] = tokenCoding8215_19; +} +x64Token x64Parser::tokenBranches8208[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8209, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8215, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8207[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8252_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8252(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8252_16; - operand.values[17] = tokenCoding8252_17; - operand.values[18] = tokenCoding8252_18; - operand.values[19] = tokenCoding8252_19; -} -x64Token x64Parser::tokenBranches8251[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8252, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8252_16; + operand.values[17] = tokenCoding8252_17; + operand.values[18] = tokenCoding8252_18; + operand.values[19] = tokenCoding8252_19; +} +x64Token x64Parser::tokenBranches8251[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8252, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8218_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8218(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8218_16; - operand.values[17] = tokenCoding8218_17; - operand.values[18] = tokenCoding8218_18; - operand.values[19] = tokenCoding8218_19; -} -x64Token x64Parser::tokenBranches8217[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8218, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8216[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8218_16; + operand.values[17] = tokenCoding8218_17; + operand.values[18] = tokenCoding8218_18; + operand.values[19] = tokenCoding8218_19; +} +x64Token x64Parser::tokenBranches8217[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8218, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8216[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8256_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8256(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8256_16; - operand.values[17] = tokenCoding8256_17; - operand.values[18] = tokenCoding8256_18; - operand.values[19] = tokenCoding8256_19; -} -x64Token x64Parser::tokenBranches8255[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8256, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8256_16; + operand.values[17] = tokenCoding8256_17; + operand.values[18] = tokenCoding8256_18; + operand.values[19] = tokenCoding8256_19; +} +x64Token x64Parser::tokenBranches8255[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8256, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8221_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8221(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8221_16; - operand.values[17] = tokenCoding8221_17; - operand.values[18] = tokenCoding8221_18; - operand.values[19] = tokenCoding8221_19; -} -x64Token x64Parser::tokenBranches8220[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8221, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8219[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8221_16; + operand.values[17] = tokenCoding8221_17; + operand.values[18] = tokenCoding8221_18; + operand.values[19] = tokenCoding8221_19; +} +x64Token x64Parser::tokenBranches8220[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8221, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8219[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8260_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8260(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8260_16; - operand.values[17] = tokenCoding8260_17; - operand.values[18] = tokenCoding8260_18; - operand.values[19] = tokenCoding8260_19; -} -x64Token x64Parser::tokenBranches8259[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8260, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8260_16; + operand.values[17] = tokenCoding8260_17; + operand.values[18] = tokenCoding8260_18; + operand.values[19] = tokenCoding8260_19; +} +x64Token x64Parser::tokenBranches8259[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8260, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8224_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8224(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8224_16; - operand.values[17] = tokenCoding8224_17; - operand.values[18] = tokenCoding8224_18; - operand.values[19] = tokenCoding8224_19; -} -x64Token x64Parser::tokenBranches8223[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8224, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8222[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8224_16; + operand.values[17] = tokenCoding8224_17; + operand.values[18] = tokenCoding8224_18; + operand.values[19] = tokenCoding8224_19; +} +x64Token x64Parser::tokenBranches8223[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8224, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8222[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8228_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8228(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8228_16; - operand.values[17] = tokenCoding8228_17; - operand.values[18] = tokenCoding8228_18; - operand.values[19] = tokenCoding8228_19; -} -x64Token x64Parser::tokenBranches8227[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8228, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8226[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8225[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8228(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8228_16; + operand.values[17] = tokenCoding8228_17; + operand.values[18] = tokenCoding8228_18; + operand.values[19] = tokenCoding8228_19; +} +x64Token x64Parser::tokenBranches8227[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8228, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8226[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8232_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8232(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8232_16; - operand.values[17] = tokenCoding8232_17; - operand.values[23] = tokenCoding8232_23; - operand.values[18] = tokenCoding8232_18; - operand.values[19] = tokenCoding8232_19; -} -x64Token x64Parser::tokenBranches8231[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8232, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8230[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8229[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8232(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8232_16; + operand.values[17] = tokenCoding8232_17; + operand.values[23] = tokenCoding8232_23; + operand.values[18] = tokenCoding8232_18; + operand.values[19] = tokenCoding8232_19; +} +x64Token x64Parser::tokenBranches8231[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8232, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8230[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8236_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8236(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8236_16; - operand.values[17] = tokenCoding8236_17; - operand.values[18] = tokenCoding8236_18; - operand.values[19] = tokenCoding8236_19; -} -x64Token x64Parser::tokenBranches8235[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8236, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8234[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8233[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8236(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8236_16; + operand.values[17] = tokenCoding8236_17; + operand.values[18] = tokenCoding8236_18; + operand.values[19] = tokenCoding8236_19; +} +x64Token x64Parser::tokenBranches8235[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8236, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8234[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8233[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8240_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8240(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8240_16; - operand.values[17] = tokenCoding8240_17; - operand.values[18] = tokenCoding8240_18; - operand.values[19] = tokenCoding8240_19; -} -x64Token x64Parser::tokenBranches8239[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8240, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8238[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8237[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8240(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8240_16; + operand.values[17] = tokenCoding8240_17; + operand.values[18] = tokenCoding8240_18; + operand.values[19] = tokenCoding8240_19; +} +x64Token x64Parser::tokenBranches8239[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8240, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8238[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8244_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8244(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8244_16; - operand.values[17] = tokenCoding8244_17; - operand.values[18] = tokenCoding8244_18; - operand.values[19] = tokenCoding8244_19; -} -x64Token x64Parser::tokenBranches8243[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8244, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8242[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8241[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8244(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8244_16; + operand.values[17] = tokenCoding8244_17; + operand.values[18] = tokenCoding8244_18; + operand.values[19] = tokenCoding8244_19; +} +x64Token x64Parser::tokenBranches8243[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8244, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8242[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8241[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8265_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8265(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8265_16; - operand.values[17] = tokenCoding8265_17; - operand.values[18] = tokenCoding8265_18; - operand.values[19] = tokenCoding8265_19; -} -x64Token x64Parser::tokenBranches8264[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8265, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8263[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8262[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8261[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262}, - {x64Token::EOT}}; + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8265_16; + operand.values[17] = tokenCoding8265_17; + operand.values[18] = tokenCoding8265_18; + operand.values[19] = tokenCoding8265_19; +} +x64Token x64Parser::tokenBranches8264[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8265, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8263[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8262[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8261[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8270_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8270(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8270_16; - operand.values[17] = tokenCoding8270_17; - operand.values[18] = tokenCoding8270_18; - operand.values[19] = tokenCoding8270_19; -} -x64Token x64Parser::tokenBranches8269[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8270, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8268[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8267[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8266[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267}, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8270_16; + operand.values[17] = tokenCoding8270_17; + operand.values[18] = tokenCoding8270_18; + operand.values[19] = tokenCoding8270_19; +} +x64Token x64Parser::tokenBranches8269[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8270, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8268[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8267[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8266[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8275_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8275_16; - operand.values[17] = tokenCoding8275_17; - operand.values[18] = tokenCoding8275_18; - operand.values[19] = tokenCoding8275_19; -} -x64Token x64Parser::tokenBranches8274[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8275, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8273[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8272[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8271[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272}, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8275_16; + operand.values[17] = tokenCoding8275_17; + operand.values[18] = tokenCoding8275_18; + operand.values[19] = tokenCoding8275_19; +} +x64Token x64Parser::tokenBranches8274[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8275, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8273[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8272[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8271[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8280_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8280(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8280_16; - operand.values[17] = tokenCoding8280_17; - operand.values[18] = tokenCoding8280_18; - operand.values[19] = tokenCoding8280_19; -} -x64Token x64Parser::tokenBranches8279[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8280, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8278[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8277[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8276[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8225(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8229(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8233(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8237(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8241(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8280_16; + operand.values[17] = tokenCoding8280_17; + operand.values[18] = tokenCoding8280_18; + operand.values[19] = tokenCoding8280_19; +} +x64Token x64Parser::tokenBranches8279[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8280, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8278[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8277[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8276[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8167[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204}, - {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc8225, x64Parser::tokenBranches8225}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc8229, x64Parser::tokenBranches8229}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc8233, x64Parser::tokenBranches8233}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8237, x64Parser::tokenBranches8237}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8241, x64Parser::tokenBranches8241}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276}, - {x64Token::EOT}}; + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, + {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8225, x64Parser::tokenBranches8225 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8229, x64Parser::tokenBranches8229 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8233, x64Parser::tokenBranches8233 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8237, x64Parser::tokenBranches8237 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8241, x64Parser::tokenBranches8241 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8283_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8283(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8283_16; - operand.values[17] = tokenCoding8283_17; - operand.values[18] = tokenCoding8283_18; - operand.values[19] = tokenCoding8283_19; -} -x64Token x64Parser::tokenBranches8282[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8283, - }, - {x64Token::EOT}}; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8283(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8283_16; + operand.values[17] = tokenCoding8283_17; + operand.values[18] = tokenCoding8283_18; + operand.values[19] = tokenCoding8283_19; +} +x64Token x64Parser::tokenBranches8282[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8283, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8285_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8285(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8285_16; - operand.values[17] = tokenCoding8285_17; - operand.values[18] = tokenCoding8285_18; - operand.values[19] = tokenCoding8285_19; -} -x64Token x64Parser::tokenBranches8284[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8285, - }, - {x64Token::EOT}}; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8285(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8285_16; + operand.values[17] = tokenCoding8285_17; + operand.values[18] = tokenCoding8285_18; + operand.values[19] = tokenCoding8285_19; +} +x64Token x64Parser::tokenBranches8284[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8285, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8293_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8293(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8293_16; - operand.values[17] = tokenCoding8293_17; - operand.values[18] = tokenCoding8293_18; - operand.values[19] = tokenCoding8293_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8293_16; + operand.values[17] = tokenCoding8293_17; + operand.values[18] = tokenCoding8293_18; + operand.values[19] = tokenCoding8293_19; } Coding x64Parser::tokenCoding8297_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8297(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8297_16; - operand.values[17] = tokenCoding8297_17; - operand.values[23] = tokenCoding8297_23; - operand.values[18] = tokenCoding8297_18; - operand.values[19] = tokenCoding8297_19; -} -x64Token x64Parser::tokenBranches8292[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8293, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8297, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8291[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8290[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8297_16; + operand.values[17] = tokenCoding8297_17; + operand.values[23] = tokenCoding8297_23; + operand.values[18] = tokenCoding8297_18; + operand.values[19] = tokenCoding8297_19; +} +x64Token x64Parser::tokenBranches8292[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8293, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8297, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8291[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8290[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8301_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8301(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8301_16; - operand.values[17] = tokenCoding8301_17; - operand.values[18] = tokenCoding8301_18; - operand.values[19] = tokenCoding8301_19; -} -x64Token x64Parser::tokenBranches8300[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8301, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8299[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8298[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8301_16; + operand.values[17] = tokenCoding8301_17; + operand.values[18] = tokenCoding8301_18; + operand.values[19] = tokenCoding8301_19; +} +x64Token x64Parser::tokenBranches8300[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8301, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8299[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8298[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8305_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8305(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8305_16; - operand.values[17] = tokenCoding8305_17; - operand.values[18] = tokenCoding8305_18; - operand.values[19] = tokenCoding8305_19; -} -x64Token x64Parser::tokenBranches8304[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8305, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8303[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8302[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8305_16; + operand.values[17] = tokenCoding8305_17; + operand.values[18] = tokenCoding8305_18; + operand.values[19] = tokenCoding8305_19; +} +x64Token x64Parser::tokenBranches8304[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8305, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8303[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8302[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8309_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8309(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8309_16; - operand.values[17] = tokenCoding8309_17; - operand.values[18] = tokenCoding8309_18; - operand.values[19] = tokenCoding8309_19; -} -x64Token x64Parser::tokenBranches8308[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8309, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8307[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8306[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8289[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8313(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 722; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8312[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8313, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8311[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312}, {x64Token::EOT}}; -void x64Parser::TokenFunc8316(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 723; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8315[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8316, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315}, {x64Token::EOT}}; -void x64Parser::TokenFunc8319(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 724; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8318[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8319, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8317[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8309_16; + operand.values[17] = tokenCoding8309_17; + operand.values[18] = tokenCoding8309_18; + operand.values[19] = tokenCoding8309_19; +} +x64Token x64Parser::tokenBranches8308[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8309, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8307[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8306[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8289[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 722; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8312[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8313, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8311[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 723; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8315[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8316, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 724; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8318[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8319, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8317[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8340_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8340(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8340_16; - operand.values[17] = tokenCoding8340_17; - operand.values[18] = tokenCoding8340_18; - operand.values[19] = tokenCoding8340_19; -} -x64Token x64Parser::tokenBranches8339[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8340, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8322(x64Operand& operand, int tokenPos) { operand.operandCoding = 722; } -x64Token x64Parser::tokenBranches8321[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8322, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8320[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8340(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8340_16; + operand.values[17] = tokenCoding8340_17; + operand.values[18] = tokenCoding8340_18; + operand.values[19] = tokenCoding8340_19; +} +x64Token x64Parser::tokenBranches8339[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8340, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 722; +} +x64Token x64Parser::tokenBranches8321[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8322, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8344_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8344(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8344_16; - operand.values[17] = tokenCoding8344_17; - operand.values[18] = tokenCoding8344_18; - operand.values[19] = tokenCoding8344_19; -} -x64Token x64Parser::tokenBranches8343[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8344, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8325(x64Operand& operand, int tokenPos) { operand.operandCoding = 723; } -x64Token x64Parser::tokenBranches8324[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8325, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8323[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8344(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8344_16; + operand.values[17] = tokenCoding8344_17; + operand.values[18] = tokenCoding8344_18; + operand.values[19] = tokenCoding8344_19; +} +x64Token x64Parser::tokenBranches8343[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8344, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 723; +} +x64Token x64Parser::tokenBranches8324[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8325, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8323[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8348_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8348(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8348_16; - operand.values[17] = tokenCoding8348_17; - operand.values[18] = tokenCoding8348_18; - operand.values[19] = tokenCoding8348_19; -} -x64Token x64Parser::tokenBranches8347[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8348, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8328(x64Operand& operand, int tokenPos) { operand.operandCoding = 724; } -x64Token x64Parser::tokenBranches8327[] = {{ - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8328, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8326[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8348(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8348_16; + operand.values[17] = tokenCoding8348_17; + operand.values[18] = tokenCoding8348_18; + operand.values[19] = tokenCoding8348_19; +} +x64Token x64Parser::tokenBranches8347[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8348, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 724; +} +x64Token x64Parser::tokenBranches8327[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8328, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8332_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8332(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8332_16; - operand.values[17] = tokenCoding8332_17; - operand.values[18] = tokenCoding8332_18; - operand.values[19] = tokenCoding8332_19; -} -x64Token x64Parser::tokenBranches8331[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8332, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8330[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8329[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8332_16; + operand.values[17] = tokenCoding8332_17; + operand.values[18] = tokenCoding8332_18; + operand.values[19] = tokenCoding8332_19; +} +x64Token x64Parser::tokenBranches8331[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8332, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8330[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8329[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8336_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8336(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8336_16; - operand.values[17] = tokenCoding8336_17; - operand.values[23] = tokenCoding8336_23; - operand.values[18] = tokenCoding8336_18; - operand.values[19] = tokenCoding8336_19; -} -x64Token x64Parser::tokenBranches8335[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8336, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8334[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8333[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8336(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8336_16; + operand.values[17] = tokenCoding8336_17; + operand.values[23] = tokenCoding8336_23; + operand.values[18] = tokenCoding8336_18; + operand.values[19] = tokenCoding8336_19; +} +x64Token x64Parser::tokenBranches8335[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8336, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8334[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8333[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8352_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8352(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8352_16; - operand.values[17] = tokenCoding8352_17; - operand.values[18] = tokenCoding8352_18; - operand.values[19] = tokenCoding8352_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8352_16; + operand.values[17] = tokenCoding8352_17; + operand.values[18] = tokenCoding8352_18; + operand.values[19] = tokenCoding8352_19; } Coding x64Parser::tokenCoding8356_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8356(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8356_16; - operand.values[17] = tokenCoding8356_17; - operand.values[23] = tokenCoding8356_23; - operand.values[18] = tokenCoding8356_18; - operand.values[19] = tokenCoding8356_19; -} -x64Token x64Parser::tokenBranches8351[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8352, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8356, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8350[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8349[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8356_16; + operand.values[17] = tokenCoding8356_17; + operand.values[23] = tokenCoding8356_23; + operand.values[18] = tokenCoding8356_18; + operand.values[19] = tokenCoding8356_19; +} +x64Token x64Parser::tokenBranches8351[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8352, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8356, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8350[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8349[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8360_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8360(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8360_16; - operand.values[17] = tokenCoding8360_17; - operand.values[18] = tokenCoding8360_18; - operand.values[19] = tokenCoding8360_19; -} -x64Token x64Parser::tokenBranches8359[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8360, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8358[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8357[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8360_16; + operand.values[17] = tokenCoding8360_17; + operand.values[18] = tokenCoding8360_18; + operand.values[19] = tokenCoding8360_19; +} +x64Token x64Parser::tokenBranches8359[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8360, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8358[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8357[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8364_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8364(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8364_16; - operand.values[17] = tokenCoding8364_17; - operand.values[18] = tokenCoding8364_18; - operand.values[19] = tokenCoding8364_19; -} -x64Token x64Parser::tokenBranches8363[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8364, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8362[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8361[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8364_16; + operand.values[17] = tokenCoding8364_17; + operand.values[18] = tokenCoding8364_18; + operand.values[19] = tokenCoding8364_19; +} +x64Token x64Parser::tokenBranches8363[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8364, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8362[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8361[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8368_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8368(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8368_16; - operand.values[17] = tokenCoding8368_17; - operand.values[18] = tokenCoding8368_18; - operand.values[19] = tokenCoding8368_19; -} -x64Token x64Parser::tokenBranches8367[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8368, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8366[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8365[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8320(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8323(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8326(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8329(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8333(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8368_16; + operand.values[17] = tokenCoding8368_17; + operand.values[18] = tokenCoding8368_18; + operand.values[19] = tokenCoding8368_19; +} +x64Token x64Parser::tokenBranches8367[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8368, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8366[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8365[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8310[] = { - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc8320, x64Parser::tokenBranches8320}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8323, x64Parser::tokenBranches8323}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8326, x64Parser::tokenBranches8326}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc8329, x64Parser::tokenBranches8329}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc8333, x64Parser::tokenBranches8333}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8375(x64Operand& operand, int tokenPos) { operand.operandCoding = 725; } -x64Token x64Parser::tokenBranches8374[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8375, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8387(x64Operand& operand, int tokenPos) { operand.operandCoding = 727; } -x64Token x64Parser::tokenBranches8386[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8399(x64Operand& operand, int tokenPos) { operand.operandCoding = 729; } -x64Token x64Parser::tokenBranches8398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8399, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8373[] = {{x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374}, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386}, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8372[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373}, {x64Token::EOT}}; -void x64Parser::TokenFunc8381(x64Operand& operand, int tokenPos) { operand.operandCoding = 726; } -x64Token x64Parser::tokenBranches8380[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8381, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8393(x64Operand& operand, int tokenPos) { operand.operandCoding = 728; } -x64Token x64Parser::tokenBranches8392[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8393, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8405(x64Operand& operand, int tokenPos) { operand.operandCoding = 730; } -x64Token x64Parser::tokenBranches8404[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8405, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8379[] = {{x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8380}, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8392}, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8404}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8378[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379}, {x64Token::EOT}}; -void x64Parser::TokenFunc8378(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8320, x64Parser::tokenBranches8320 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8323, x64Parser::tokenBranches8323 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8333, x64Parser::tokenBranches8333 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8375(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 725; +} +x64Token x64Parser::tokenBranches8374[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8375, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 727; +} +x64Token x64Parser::tokenBranches8386[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 729; +} +x64Token x64Parser::tokenBranches8398[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8373[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8372[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8381(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 726; +} +x64Token x64Parser::tokenBranches8380[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8381, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8393(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 728; +} +x64Token x64Parser::tokenBranches8392[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8393, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8405(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 730; +} +x64Token x64Parser::tokenBranches8404[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8405, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8379[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8380 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8392 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8404 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8378[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8371[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8378, x64Parser::tokenBranches8378}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8370[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371}, {x64Token::EOT}}; -void x64Parser::TokenFunc8406(x64Operand& operand, int tokenPos) { operand.operandCoding = 731; } -x64Token x64Parser::tokenBranches8369[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc8406, - }, - {x64Token::EOT}}; + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8378, x64Parser::tokenBranches8378 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8370[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8406(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 731; +} +x64Token x64Parser::tokenBranches8369[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8406, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8410_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8410(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8410_16; - operand.values[17] = tokenCoding8410_17; - operand.values[18] = tokenCoding8410_18; - operand.values[19] = tokenCoding8410_19; -} -x64Token x64Parser::tokenBranches8409[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8410, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8410(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8410_16; + operand.values[17] = tokenCoding8410_17; + operand.values[18] = tokenCoding8410_18; + operand.values[19] = tokenCoding8410_19; +} +x64Token x64Parser::tokenBranches8409[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8410, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8412_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8412(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8412_16; - operand.values[17] = tokenCoding8412_17; - operand.values[18] = tokenCoding8412_18; - operand.values[19] = tokenCoding8412_19; -} -x64Token x64Parser::tokenBranches8411[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8412, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8412_16; + operand.values[17] = tokenCoding8412_17; + operand.values[18] = tokenCoding8412_18; + operand.values[19] = tokenCoding8412_19; +} +x64Token x64Parser::tokenBranches8411[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8412, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8414_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8414(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8414_16; - operand.values[17] = tokenCoding8414_17; - operand.values[18] = tokenCoding8414_18; - operand.values[19] = tokenCoding8414_19; -} -x64Token x64Parser::tokenBranches8413[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8414, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8414(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8414_16; + operand.values[17] = tokenCoding8414_17; + operand.values[18] = tokenCoding8414_18; + operand.values[19] = tokenCoding8414_19; +} +x64Token x64Parser::tokenBranches8413[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8414, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8416_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8416(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8416_16; - operand.values[17] = tokenCoding8416_17; - operand.values[18] = tokenCoding8416_18; - operand.values[19] = tokenCoding8416_19; -} -x64Token x64Parser::tokenBranches8415[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8416, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8416_16; + operand.values[17] = tokenCoding8416_17; + operand.values[18] = tokenCoding8416_18; + operand.values[19] = tokenCoding8416_19; +} +x64Token x64Parser::tokenBranches8415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8469_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8469(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8469_16; - operand.values[17] = tokenCoding8469_17; - operand.values[23] = tokenCoding8469_23; - operand.values[18] = tokenCoding8469_18; - operand.values[19] = tokenCoding8469_19; -} -x64Token x64Parser::tokenBranches8468[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8469, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8467[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468}, {x64Token::EOT}}; -void x64Parser::TokenFunc8467(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8469(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8469_16; + operand.values[17] = tokenCoding8469_17; + operand.values[23] = tokenCoding8469_23; + operand.values[18] = tokenCoding8469_18; + operand.values[19] = tokenCoding8469_19; +} +x64Token x64Parser::tokenBranches8468[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8469, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8467[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8466[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8467, x64Parser::tokenBranches8467}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8467, x64Parser::tokenBranches8467 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8473_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8473(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8473_16; - operand.values[17] = tokenCoding8473_17; - operand.values[23] = tokenCoding8473_23; - operand.values[18] = tokenCoding8473_18; - operand.values[19] = tokenCoding8473_19; -} -x64Token x64Parser::tokenBranches8472[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8473, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8471[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472}, {x64Token::EOT}}; -void x64Parser::TokenFunc8471(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8473_16; + operand.values[17] = tokenCoding8473_17; + operand.values[23] = tokenCoding8473_23; + operand.values[18] = tokenCoding8473_18; + operand.values[19] = tokenCoding8473_19; +} +x64Token x64Parser::tokenBranches8472[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8473, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8471[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8470[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8471, x64Parser::tokenBranches8471}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8471, x64Parser::tokenBranches8471 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8490_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8490(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8490_16; - operand.values[17] = tokenCoding8490_17; - operand.values[23] = tokenCoding8490_23; - operand.values[18] = tokenCoding8490_18; - operand.values[19] = tokenCoding8490_19; -} -x64Token x64Parser::tokenBranches8489[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8490, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8488[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8490(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8490_16; + operand.values[17] = tokenCoding8490_17; + operand.values[23] = tokenCoding8490_23; + operand.values[18] = tokenCoding8490_18; + operand.values[19] = tokenCoding8490_19; +} +x64Token x64Parser::tokenBranches8489[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8490, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8488[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8493_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8493(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8493_16; - operand.values[17] = tokenCoding8493_17; - operand.values[23] = tokenCoding8493_23; - operand.values[18] = tokenCoding8493_18; - operand.values[19] = tokenCoding8493_19; -} -x64Token x64Parser::tokenBranches8492[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8493, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8491[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8493(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8493_16; + operand.values[17] = tokenCoding8493_17; + operand.values[23] = tokenCoding8493_23; + operand.values[18] = tokenCoding8493_18; + operand.values[19] = tokenCoding8493_19; +} +x64Token x64Parser::tokenBranches8492[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8493, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8491[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8496_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8496(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8496_16; - operand.values[17] = tokenCoding8496_17; - operand.values[23] = tokenCoding8496_23; - operand.values[18] = tokenCoding8496_18; - operand.values[19] = tokenCoding8496_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8496_16; + operand.values[17] = tokenCoding8496_17; + operand.values[23] = tokenCoding8496_23; + operand.values[18] = tokenCoding8496_18; + operand.values[19] = tokenCoding8496_19; } Coding x64Parser::tokenCoding8499_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8499(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8499_16; - operand.values[17] = tokenCoding8499_17; - operand.values[23] = tokenCoding8499_23; - operand.values[18] = tokenCoding8499_18; - operand.values[19] = tokenCoding8499_19; -} -x64Token x64Parser::tokenBranches8495[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8496, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8499, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8494[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495}, {x64Token::EOT}}; -void x64Parser::TokenFunc8488(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8491(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8499_16; + operand.values[17] = tokenCoding8499_17; + operand.values[23] = tokenCoding8499_23; + operand.values[18] = tokenCoding8499_18; + operand.values[19] = tokenCoding8499_19; +} +x64Token x64Parser::tokenBranches8495[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8496, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8499, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8494[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8487[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8488, x64Parser::tokenBranches8488}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8491, x64Parser::tokenBranches8491}, - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8488, x64Parser::tokenBranches8488 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8491, x64Parser::tokenBranches8491 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8503_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8503(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8503_16; - operand.values[17] = tokenCoding8503_17; - operand.values[23] = tokenCoding8503_23; - operand.values[18] = tokenCoding8503_18; - operand.values[19] = tokenCoding8503_19; -} -x64Token x64Parser::tokenBranches8502[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8503, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8501[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8503_16; + operand.values[17] = tokenCoding8503_17; + operand.values[23] = tokenCoding8503_23; + operand.values[18] = tokenCoding8503_18; + operand.values[19] = tokenCoding8503_19; +} +x64Token x64Parser::tokenBranches8502[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8503, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8501[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8506_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8506(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8506_16; - operand.values[17] = tokenCoding8506_17; - operand.values[23] = tokenCoding8506_23; - operand.values[18] = tokenCoding8506_18; - operand.values[19] = tokenCoding8506_19; -} -x64Token x64Parser::tokenBranches8505[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8506, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8504[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8506(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8506_16; + operand.values[17] = tokenCoding8506_17; + operand.values[23] = tokenCoding8506_23; + operand.values[18] = tokenCoding8506_18; + operand.values[19] = tokenCoding8506_19; +} +x64Token x64Parser::tokenBranches8505[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8506, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8504[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8509_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8509(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8509_16; - operand.values[17] = tokenCoding8509_17; - operand.values[23] = tokenCoding8509_23; - operand.values[18] = tokenCoding8509_18; - operand.values[19] = tokenCoding8509_19; + operand.values[16] = tokenCoding8509_16; + operand.values[17] = tokenCoding8509_17; + operand.values[23] = tokenCoding8509_23; + operand.values[18] = tokenCoding8509_18; + operand.values[19] = tokenCoding8509_19; } Coding x64Parser::tokenCoding8512_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8512(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8512_16; - operand.values[17] = tokenCoding8512_17; - operand.values[23] = tokenCoding8512_23; - operand.values[18] = tokenCoding8512_18; - operand.values[19] = tokenCoding8512_19; -} -x64Token x64Parser::tokenBranches8508[] = {{ - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc8509, - }, - { - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8512, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8507[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8512_16; + operand.values[17] = tokenCoding8512_17; + operand.values[23] = tokenCoding8512_23; + operand.values[18] = tokenCoding8512_18; + operand.values[19] = tokenCoding8512_19; +} +x64Token x64Parser::tokenBranches8508[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8509, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8507[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8515_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8515(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8515_16; - operand.values[17] = tokenCoding8515_17; - operand.values[23] = tokenCoding8515_23; - operand.values[18] = tokenCoding8515_18; - operand.values[19] = tokenCoding8515_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8515_16; + operand.values[17] = tokenCoding8515_17; + operand.values[23] = tokenCoding8515_23; + operand.values[18] = tokenCoding8515_18; + operand.values[19] = tokenCoding8515_19; } Coding x64Parser::tokenCoding8521_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8521(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8521_16; - operand.values[17] = tokenCoding8521_17; - operand.values[23] = tokenCoding8521_23; - operand.values[18] = tokenCoding8521_18; - operand.values[19] = tokenCoding8521_19; -} -x64Token x64Parser::tokenBranches8514[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8515, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8521, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8513[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8521(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8521_16; + operand.values[17] = tokenCoding8521_17; + operand.values[23] = tokenCoding8521_23; + operand.values[18] = tokenCoding8521_18; + operand.values[19] = tokenCoding8521_19; +} +x64Token x64Parser::tokenBranches8514[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8515, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8521, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8513[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8518_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8518(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8518_16; - operand.values[17] = tokenCoding8518_17; - operand.values[23] = tokenCoding8518_23; - operand.values[18] = tokenCoding8518_18; - operand.values[19] = tokenCoding8518_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8518_16; + operand.values[17] = tokenCoding8518_17; + operand.values[23] = tokenCoding8518_23; + operand.values[18] = tokenCoding8518_18; + operand.values[19] = tokenCoding8518_19; } Coding x64Parser::tokenCoding8524_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8524(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8524_16; - operand.values[17] = tokenCoding8524_17; - operand.values[23] = tokenCoding8524_23; - operand.values[18] = tokenCoding8524_18; - operand.values[19] = tokenCoding8524_19; -} -x64Token x64Parser::tokenBranches8517[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8518, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8524, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8516[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517}, {x64Token::EOT}}; -void x64Parser::TokenFunc8504(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8507(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8524_16; + operand.values[17] = tokenCoding8524_17; + operand.values[23] = tokenCoding8524_23; + operand.values[18] = tokenCoding8524_18; + operand.values[19] = tokenCoding8524_19; +} +x64Token x64Parser::tokenBranches8517[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8518, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8524, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8516[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8500[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501}, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8504, x64Parser::tokenBranches8504}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8507, x64Parser::tokenBranches8507}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513}, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516}, - {x64Token::EOT}}; + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8504, x64Parser::tokenBranches8504 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8507, x64Parser::tokenBranches8507 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8532_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8532(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8532_16; - operand.values[17] = tokenCoding8532_17; - operand.values[23] = tokenCoding8532_23; - operand.values[18] = tokenCoding8532_18; - operand.values[19] = tokenCoding8532_19; -} -x64Token x64Parser::tokenBranches8531[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc8532, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8530[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531}, {x64Token::EOT}}; -void x64Parser::TokenFunc8530(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8532(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8532_16; + operand.values[17] = tokenCoding8532_17; + operand.values[23] = tokenCoding8532_23; + operand.values[18] = tokenCoding8532_18; + operand.values[19] = tokenCoding8532_19; +} +x64Token x64Parser::tokenBranches8531[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8532, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8530[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8529[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8530, x64Parser::tokenBranches8530}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8530, x64Parser::tokenBranches8530 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8538_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8538(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8538_16; - operand.values[17] = tokenCoding8538_17; - operand.values[23] = tokenCoding8538_23; - operand.values[18] = tokenCoding8538_18; - operand.values[19] = tokenCoding8538_19; -} -x64Token x64Parser::tokenBranches8537[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc8538, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8536[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537}, {x64Token::EOT}}; -void x64Parser::TokenFunc8536(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8538_16; + operand.values[17] = tokenCoding8538_17; + operand.values[23] = tokenCoding8538_23; + operand.values[18] = tokenCoding8538_18; + operand.values[19] = tokenCoding8538_19; +} +x64Token x64Parser::tokenBranches8537[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8535[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8536, x64Parser::tokenBranches8536}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8546_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8546(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8546_16; - operand.values[17] = tokenCoding8546_17; - operand.values[23] = tokenCoding8546_23; - operand.values[18] = tokenCoding8546_18; - operand.values[19] = tokenCoding8546_19; -} -x64Token x64Parser::tokenBranches8545[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8544[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8543[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8546_16; + operand.values[17] = tokenCoding8546_17; + operand.values[23] = tokenCoding8546_23; + operand.values[18] = tokenCoding8546_18; + operand.values[19] = tokenCoding8546_19; +} +x64Token x64Parser::tokenBranches8545[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8546, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8544[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8543[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8550_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8550_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8550_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8550(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8550_16; - operand.values[17] = tokenCoding8550_17; - operand.values[18] = tokenCoding8550_18; + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8550_16; + operand.values[17] = tokenCoding8550_17; + operand.values[18] = tokenCoding8550_18; } Coding x64Parser::tokenCoding8553_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8553_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8553_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8553(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8553_16; - operand.values[17] = tokenCoding8553_17; - operand.values[18] = tokenCoding8553_18; -} -x64Token x64Parser::tokenBranches8549[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8550, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8553, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8548[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8547[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8553_16; + operand.values[17] = tokenCoding8553_17; + operand.values[18] = tokenCoding8553_18; +} +x64Token x64Parser::tokenBranches8549[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8550, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8553, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8548[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8547[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8557_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8557(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8557_16; - operand.values[17] = tokenCoding8557_17; - operand.values[23] = tokenCoding8557_23; - operand.values[18] = tokenCoding8557_18; - operand.values[19] = tokenCoding8557_19; -} -x64Token x64Parser::tokenBranches8556[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8557, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8555[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8554[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8557_16; + operand.values[17] = tokenCoding8557_17; + operand.values[23] = tokenCoding8557_23; + operand.values[18] = tokenCoding8557_18; + operand.values[19] = tokenCoding8557_19; +} +x64Token x64Parser::tokenBranches8556[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8557, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8555[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8554[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8561_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8561(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8561_16; - operand.values[17] = tokenCoding8561_17; - operand.values[23] = tokenCoding8561_23; - operand.values[18] = tokenCoding8561_18; - operand.values[19] = tokenCoding8561_19; -} -x64Token x64Parser::tokenBranches8560[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8561, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8559[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8558[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8561_16; + operand.values[17] = tokenCoding8561_17; + operand.values[23] = tokenCoding8561_23; + operand.values[18] = tokenCoding8561_18; + operand.values[19] = tokenCoding8561_19; +} +x64Token x64Parser::tokenBranches8560[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8561, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8559[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8558[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8565_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8565(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8565_16; - operand.values[17] = tokenCoding8565_17; - operand.values[23] = tokenCoding8565_23; - operand.values[18] = tokenCoding8565_18; - operand.values[19] = tokenCoding8565_19; -} -x64Token x64Parser::tokenBranches8564[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8565, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8563[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8562[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8565_16; + operand.values[17] = tokenCoding8565_17; + operand.values[23] = tokenCoding8565_23; + operand.values[18] = tokenCoding8565_18; + operand.values[19] = tokenCoding8565_19; +} +x64Token x64Parser::tokenBranches8564[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8565, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8563[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8562[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8569_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_23[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8569(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8569_16; - operand.values[17] = tokenCoding8569_17; - operand.values[23] = tokenCoding8569_23; - operand.values[18] = tokenCoding8569_18; - operand.values[19] = tokenCoding8569_19; -} -x64Token x64Parser::tokenBranches8568[] = {{ - x64Token::ADDRESSCLASS, - 24, - 1, - 0, - NULL, - &x64Parser::TokenFunc8569, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8567[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568}, {x64Token::EOT}}; -void x64Parser::TokenFunc8567(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8569(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8569_16; + operand.values[17] = tokenCoding8569_17; + operand.values[23] = tokenCoding8569_23; + operand.values[18] = tokenCoding8569_18; + operand.values[19] = tokenCoding8569_19; +} +x64Token x64Parser::tokenBranches8568[] = { + {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8569, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8566[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8567, x64Parser::tokenBranches8567}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8567, x64Parser::tokenBranches8567 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8597_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8597(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8597_16; - operand.values[17] = tokenCoding8597_17; - operand.values[23] = tokenCoding8597_23; - operand.values[18] = tokenCoding8597_18; -} -x64Token x64Parser::tokenBranches8596[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8597, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8595[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8594[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8593[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8597_16; + operand.values[17] = tokenCoding8597_17; + operand.values[23] = tokenCoding8597_23; + operand.values[18] = tokenCoding8597_18; +} +x64Token x64Parser::tokenBranches8596[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8597, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8595[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8594[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8593[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8602_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8602(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8602_16; - operand.values[17] = tokenCoding8602_17; - operand.values[23] = tokenCoding8602_23; - operand.values[18] = tokenCoding8602_18; -} -x64Token x64Parser::tokenBranches8601[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8602, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8600[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8599[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8598[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599}, {x64Token::EOT}}; -void x64Parser::TokenFunc8593(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8598(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8602_16; + operand.values[17] = tokenCoding8602_17; + operand.values[23] = tokenCoding8602_23; + operand.values[18] = tokenCoding8602_18; +} +x64Token x64Parser::tokenBranches8601[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8602, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8600[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8599[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8598[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8598(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8592[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8593, x64Parser::tokenBranches8593}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8598, x64Parser::tokenBranches8598}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8593, x64Parser::tokenBranches8593 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8598, x64Parser::tokenBranches8598 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8621_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8621(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8621_16; - operand.values[17] = tokenCoding8621_17; - operand.values[23] = tokenCoding8621_23; - operand.values[18] = tokenCoding8621_18; -} -x64Token x64Parser::tokenBranches8620[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8621, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8619[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620}, {x64Token::EOT}}; -void x64Parser::TokenFunc8619(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8621(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8621_16; + operand.values[17] = tokenCoding8621_17; + operand.values[23] = tokenCoding8621_23; + operand.values[18] = tokenCoding8621_18; +} +x64Token x64Parser::tokenBranches8620[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8621, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8619[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8618[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8619, x64Parser::tokenBranches8619}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8617[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8616[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8619, x64Parser::tokenBranches8619 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8617[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8616[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8627_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8627(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8627_16; - operand.values[17] = tokenCoding8627_17; - operand.values[23] = tokenCoding8627_23; - operand.values[18] = tokenCoding8627_18; -} -x64Token x64Parser::tokenBranches8626[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8627, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8625[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8626}, {x64Token::EOT}}; -void x64Parser::TokenFunc8625(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8627(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8627_16; + operand.values[17] = tokenCoding8627_17; + operand.values[23] = tokenCoding8627_23; + operand.values[18] = tokenCoding8627_18; +} +x64Token x64Parser::tokenBranches8626[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8627, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8625[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8626 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8625(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8624[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8625, x64Parser::tokenBranches8625}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8623[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8624}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8622[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8623}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8625, x64Parser::tokenBranches8625 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8623[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8624 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8622[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8623 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8633_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8633(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8633_16; - operand.values[17] = tokenCoding8633_17; - operand.values[23] = tokenCoding8633_23; - operand.values[18] = tokenCoding8633_18; -} -x64Token x64Parser::tokenBranches8632[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8633, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8631[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8632}, {x64Token::EOT}}; -void x64Parser::TokenFunc8631(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8633(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8633_16; + operand.values[17] = tokenCoding8633_17; + operand.values[23] = tokenCoding8633_23; + operand.values[18] = tokenCoding8633_18; +} +x64Token x64Parser::tokenBranches8632[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8633, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8631[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8632 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8631(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8630[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8631, x64Parser::tokenBranches8631}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8629[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8630}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8628[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8631, x64Parser::tokenBranches8631 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8630 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8628[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8639_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8639(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8639_16; - operand.values[17] = tokenCoding8639_17; - operand.values[23] = tokenCoding8639_23; - operand.values[18] = tokenCoding8639_18; - operand.values[19] = tokenCoding8639_19; -} -x64Token x64Parser::tokenBranches8638[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8639, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8637[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8638}, {x64Token::EOT}}; -void x64Parser::TokenFunc8637(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8639_16; + operand.values[17] = tokenCoding8639_17; + operand.values[23] = tokenCoding8639_23; + operand.values[18] = tokenCoding8639_18; + operand.values[19] = tokenCoding8639_19; +} +x64Token x64Parser::tokenBranches8638[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8639, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8637[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8638 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8637(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8636[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8637, x64Parser::tokenBranches8637}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8635[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8644_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8644(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8644_16; - operand.values[17] = tokenCoding8644_17; - operand.values[23] = tokenCoding8644_23; - operand.values[18] = tokenCoding8644_18; - operand.values[19] = tokenCoding8644_19; -} -x64Token x64Parser::tokenBranches8643[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8644, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8642[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8641[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8640[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8644_16; + operand.values[17] = tokenCoding8644_17; + operand.values[23] = tokenCoding8644_23; + operand.values[18] = tokenCoding8644_18; + operand.values[19] = tokenCoding8644_19; +} +x64Token x64Parser::tokenBranches8643[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8644, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8642[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8641[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8640[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8649_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8649(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8649_16; - operand.values[17] = tokenCoding8649_17; - operand.values[23] = tokenCoding8649_23; - operand.values[18] = tokenCoding8649_18; - operand.values[19] = tokenCoding8649_19; -} -x64Token x64Parser::tokenBranches8648[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8649, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8647[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8646[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8649_16; + operand.values[17] = tokenCoding8649_17; + operand.values[23] = tokenCoding8649_23; + operand.values[18] = tokenCoding8649_18; + operand.values[19] = tokenCoding8649_19; +} +x64Token x64Parser::tokenBranches8648[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8649, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8647[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8646[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8654_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8654(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8654_16; - operand.values[17] = tokenCoding8654_17; - operand.values[23] = tokenCoding8654_23; - operand.values[18] = tokenCoding8654_18; - operand.values[19] = tokenCoding8654_19; -} -x64Token x64Parser::tokenBranches8653[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8654, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8652[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653}, {x64Token::EOT}}; -void x64Parser::TokenFunc8652(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8654_16; + operand.values[17] = tokenCoding8654_17; + operand.values[23] = tokenCoding8654_23; + operand.values[18] = tokenCoding8654_18; + operand.values[19] = tokenCoding8654_19; +} +x64Token x64Parser::tokenBranches8653[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8654, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8652[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8652(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8651[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8652, x64Parser::tokenBranches8652}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8650[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651}, {x64Token::EOT}}; -void x64Parser::TokenFunc8640(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8645(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8652, x64Parser::tokenBranches8652 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8650[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8640(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8634[] = { - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8640, x64Parser::tokenBranches8640}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8645, x64Parser::tokenBranches8645}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650}, - {x64Token::EOT}}; + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8640, x64Parser::tokenBranches8640 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8645, x64Parser::tokenBranches8645 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8660_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8660(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8660_16; - operand.values[17] = tokenCoding8660_17; - operand.values[23] = tokenCoding8660_23; - operand.values[18] = tokenCoding8660_18; -} -x64Token x64Parser::tokenBranches8659[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8660, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8658[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8657[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8656[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657}, {x64Token::EOT}}; -void x64Parser::TokenFunc8656(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8660_16; + operand.values[17] = tokenCoding8660_17; + operand.values[23] = tokenCoding8660_23; + operand.values[18] = tokenCoding8660_18; +} +x64Token x64Parser::tokenBranches8659[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8660, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8658[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8657[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8656[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8655[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8656, x64Parser::tokenBranches8656}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8656, x64Parser::tokenBranches8656 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8666_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8666(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8666_16; - operand.values[17] = tokenCoding8666_17; - operand.values[23] = tokenCoding8666_23; - operand.values[18] = tokenCoding8666_18; -} -x64Token x64Parser::tokenBranches8665[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8666, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8664[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8665}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8663[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8664}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8662[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8663}, {x64Token::EOT}}; -void x64Parser::TokenFunc8662(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8666(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8666_16; + operand.values[17] = tokenCoding8666_17; + operand.values[23] = tokenCoding8666_23; + operand.values[18] = tokenCoding8666_18; +} +x64Token x64Parser::tokenBranches8665[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8666, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8664[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8665 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8663[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8664 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8662[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8663 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8662(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8661[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8662, x64Parser::tokenBranches8662}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8662, x64Parser::tokenBranches8662 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8672_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8672(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8672_16; - operand.values[17] = tokenCoding8672_17; - operand.values[23] = tokenCoding8672_23; - operand.values[18] = tokenCoding8672_18; -} -x64Token x64Parser::tokenBranches8671[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8672, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8670[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8671}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8669[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8668[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8669}, {x64Token::EOT}}; -void x64Parser::TokenFunc8668(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8672(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8672_16; + operand.values[17] = tokenCoding8672_17; + operand.values[23] = tokenCoding8672_23; + operand.values[18] = tokenCoding8672_18; +} +x64Token x64Parser::tokenBranches8671[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8672, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8670[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8671 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8669[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8668[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8669 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8668(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8667[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8668, x64Parser::tokenBranches8668}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8668, x64Parser::tokenBranches8668 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8678_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8678(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8678_16; - operand.values[17] = tokenCoding8678_17; - operand.values[23] = tokenCoding8678_23; - operand.values[18] = tokenCoding8678_18; - operand.values[19] = tokenCoding8678_19; -} -x64Token x64Parser::tokenBranches8677[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8678, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8676[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8677}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8675[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8674[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8678_16; + operand.values[17] = tokenCoding8678_17; + operand.values[23] = tokenCoding8678_23; + operand.values[18] = tokenCoding8678_18; + operand.values[19] = tokenCoding8678_19; +} +x64Token x64Parser::tokenBranches8677[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8678, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8676[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8677 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8675[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8674[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8683_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8683(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8683_16; - operand.values[17] = tokenCoding8683_17; - operand.values[23] = tokenCoding8683_23; - operand.values[18] = tokenCoding8683_18; - operand.values[19] = tokenCoding8683_19; -} -x64Token x64Parser::tokenBranches8682[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8683, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8681[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8683_16; + operand.values[17] = tokenCoding8683_17; + operand.values[23] = tokenCoding8683_23; + operand.values[18] = tokenCoding8683_18; + operand.values[19] = tokenCoding8683_19; +} +x64Token x64Parser::tokenBranches8682[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8683, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8688_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8688(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8688_16; - operand.values[17] = tokenCoding8688_17; - operand.values[23] = tokenCoding8688_23; - operand.values[18] = tokenCoding8688_18; - operand.values[19] = tokenCoding8688_19; -} -x64Token x64Parser::tokenBranches8687[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8688, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8686[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8688_16; + operand.values[17] = tokenCoding8688_17; + operand.values[23] = tokenCoding8688_23; + operand.values[18] = tokenCoding8688_18; + operand.values[19] = tokenCoding8688_19; +} +x64Token x64Parser::tokenBranches8687[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8688, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8686[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8693_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8693(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8693_16; - operand.values[17] = tokenCoding8693_17; - operand.values[23] = tokenCoding8693_23; - operand.values[18] = tokenCoding8693_18; - operand.values[19] = tokenCoding8693_19; -} -x64Token x64Parser::tokenBranches8692[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8693, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8691[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8680[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686}, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8679[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680}, {x64Token::EOT}}; -void x64Parser::TokenFunc8674(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8679(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8693_16; + operand.values[17] = tokenCoding8693_17; + operand.values[23] = tokenCoding8693_23; + operand.values[18] = tokenCoding8693_18; + operand.values[19] = tokenCoding8693_19; +} +x64Token x64Parser::tokenBranches8692[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8693, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8691[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8680[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8679[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8673[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8674, x64Parser::tokenBranches8674}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8679, x64Parser::tokenBranches8679}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8679, x64Parser::tokenBranches8679 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8702_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8702(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8702(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8702_16; - operand.values[17] = tokenCoding8702_17; - operand.values[23] = tokenCoding8702_23; - operand.values[18] = tokenCoding8702_18; + operand.values[16] = tokenCoding8702_16; + operand.values[17] = tokenCoding8702_17; + operand.values[23] = tokenCoding8702_23; + operand.values[18] = tokenCoding8702_18; } Coding x64Parser::tokenCoding8708_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8708(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8708_16; - operand.values[17] = tokenCoding8708_17; - operand.values[23] = tokenCoding8708_23; - operand.values[18] = tokenCoding8708_18; -} -x64Token x64Parser::tokenBranches8701[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8702, - }, - { - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8708, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8700[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8708_16; + operand.values[17] = tokenCoding8708_17; + operand.values[23] = tokenCoding8708_23; + operand.values[18] = tokenCoding8708_18; +} +x64Token x64Parser::tokenBranches8701[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8702, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8708, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8700[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8705_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8705(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8705(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8705_16; - operand.values[17] = tokenCoding8705_17; - operand.values[23] = tokenCoding8705_23; - operand.values[18] = tokenCoding8705_18; + operand.values[16] = tokenCoding8705_16; + operand.values[17] = tokenCoding8705_17; + operand.values[23] = tokenCoding8705_23; + operand.values[18] = tokenCoding8705_18; } Coding x64Parser::tokenCoding8711_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8711(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8711_16; - operand.values[17] = tokenCoding8711_17; - operand.values[23] = tokenCoding8711_23; - operand.values[18] = tokenCoding8711_18; -} -x64Token x64Parser::tokenBranches8704[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8705, - }, - { - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8711, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8703[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704}, {x64Token::EOT}}; -void x64Parser::TokenFunc8700(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8703(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8711_16; + operand.values[17] = tokenCoding8711_17; + operand.values[23] = tokenCoding8711_23; + operand.values[18] = tokenCoding8711_18; +} +x64Token x64Parser::tokenBranches8704[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8705, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8711, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8703[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8699[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8700, x64Parser::tokenBranches8700}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8703, x64Parser::tokenBranches8703}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8700, x64Parser::tokenBranches8700 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8703, x64Parser::tokenBranches8703 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8725_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8725_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8725_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8725(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8725_16; - operand.values[17] = tokenCoding8725_17; - operand.values[18] = tokenCoding8725_18; -} -x64Token x64Parser::tokenBranches8724[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8725, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8723[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8722[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8721[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722}, {x64Token::EOT}}; -void x64Parser::TokenFunc8721(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8725_16; + operand.values[17] = tokenCoding8725_17; + operand.values[18] = tokenCoding8725_18; +} +x64Token x64Parser::tokenBranches8724[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8725, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8723[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8722[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8721[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8720[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8721, x64Parser::tokenBranches8721}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8721, x64Parser::tokenBranches8721 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8730_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8730_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8730_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8730(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8730_16; - operand.values[17] = tokenCoding8730_17; - operand.values[18] = tokenCoding8730_18; -} -x64Token x64Parser::tokenBranches8729[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8730, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8728[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8727[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728}, - {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8730_16; + operand.values[17] = tokenCoding8730_17; + operand.values[18] = tokenCoding8730_18; +} +x64Token x64Parser::tokenBranches8729[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8730, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8728[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8727[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8739_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8739_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8739_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8739(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) { - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8739_16; - operand.values[17] = tokenCoding8739_17; - operand.values[18] = tokenCoding8739_18; + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8739_16; + operand.values[17] = tokenCoding8739_17; + operand.values[18] = tokenCoding8739_18; } -x64Token x64Parser::tokenBranches8738[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8739, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8737[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8736[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737}, - {x64Token::EOT}}; -asmError x64Parser::Opcode0(x64Operand& operand) +x64Token x64Parser::tokenBranches8738[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8739, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8737[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8736[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737 }, + {x64Token::EOT } +}; +asmError x64Parser::Opcode0(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5267, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5267, operand); + return rv; } -asmError x64Parser::Opcode1(x64Operand& operand) +asmError x64Parser::Opcode1(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5269, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5269, operand); + return rv; } -asmError x64Parser::Opcode2(x64Operand& operand) +asmError x64Parser::Opcode2(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5271, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5271, operand); + return rv; } -asmError x64Parser::Opcode3(x64Operand& operand) +asmError x64Parser::Opcode3(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5296, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5296, operand); + return rv; } -asmError x64Parser::Opcode4(x64Operand& operand) +asmError x64Parser::Opcode4(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5309, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5309, operand); + return rv; } -asmError x64Parser::Opcode5(x64Operand& operand) +asmError x64Parser::Opcode5(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5483, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5483, operand); + return rv; } -asmError x64Parser::Opcode6(x64Operand& operand) +asmError x64Parser::Opcode6(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5511, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5511, operand); + return rv; } -asmError x64Parser::Opcode7(x64Operand& operand) +asmError x64Parser::Opcode7(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5527, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5527, operand); + return rv; } -asmError x64Parser::Opcode8(x64Operand& operand) +asmError x64Parser::Opcode8(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5540, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5540, operand); + return rv; } -asmError x64Parser::Opcode9(x64Operand& operand) +asmError x64Parser::Opcode9(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5552, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5552, operand); + return rv; } -asmError x64Parser::Opcode10(x64Operand& operand) +asmError x64Parser::Opcode10(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5558, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5558, operand); + return rv; } -asmError x64Parser::Opcode11(x64Operand& operand) +asmError x64Parser::Opcode11(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5563, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5563, operand); + return rv; } -asmError x64Parser::Opcode12(x64Operand& operand) +asmError x64Parser::Opcode12(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5566, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5566, operand); + return rv; } -asmError x64Parser::Opcode13(x64Operand& operand) +asmError x64Parser::Opcode13(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5575, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5575, operand); + return rv; } -asmError x64Parser::Opcode14(x64Operand& operand) +asmError x64Parser::Opcode14(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5588, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5588, operand); + return rv; } -asmError x64Parser::Opcode15(x64Operand& operand) +asmError x64Parser::Opcode15(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5591, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5591, operand); + return rv; } -asmError x64Parser::Opcode16(x64Operand& operand) +asmError x64Parser::Opcode16(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5634, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5634, operand); + return rv; } -asmError x64Parser::Opcode17(x64Operand& operand) +asmError x64Parser::Opcode17(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5729, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5729, operand); + return rv; } -asmError x64Parser::Opcode18(x64Operand& operand) +asmError x64Parser::Opcode18(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5766, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5766, operand); + return rv; } -asmError x64Parser::Opcode19(x64Operand& operand) +asmError x64Parser::Opcode19(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5768, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5768, operand); + return rv; } -asmError x64Parser::Opcode20(x64Operand& operand) +asmError x64Parser::Opcode20(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5772, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5772, operand); + return rv; } -asmError x64Parser::Opcode21(x64Operand& operand) +asmError x64Parser::Opcode21(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5779, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5779, operand); + return rv; } -asmError x64Parser::Opcode22(x64Operand& operand) +asmError x64Parser::Opcode22(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5786, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5786, operand); + return rv; } -asmError x64Parser::Opcode23(x64Operand& operand) +asmError x64Parser::Opcode23(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5793, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5793, operand); + return rv; } -asmError x64Parser::Opcode24(x64Operand& operand) +asmError x64Parser::Opcode24(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5797, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5797, operand); + return rv; } -asmError x64Parser::Opcode25(x64Operand& operand) +asmError x64Parser::Opcode25(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5801, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5801, operand); + return rv; } -asmError x64Parser::Opcode26(x64Operand& operand) +asmError x64Parser::Opcode26(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5808, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5808, operand); + return rv; } -asmError x64Parser::Opcode27(x64Operand& operand) +asmError x64Parser::Opcode27(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5817, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5817, operand); + return rv; } -asmError x64Parser::Opcode28(x64Operand& operand) +asmError x64Parser::Opcode28(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5824, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5824, operand); + return rv; } -asmError x64Parser::Opcode29(x64Operand& operand) +asmError x64Parser::Opcode29(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5830, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5830, operand); + return rv; } -asmError x64Parser::Opcode30(x64Operand& operand) +asmError x64Parser::Opcode30(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5843, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5843, operand); + return rv; } -asmError x64Parser::Opcode31(x64Operand& operand) +asmError x64Parser::Opcode31(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5849, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5849, operand); + return rv; } Coding x64Parser::OpcodeCodings32_19[] = { - {CODING_NAME("aaa") Coding::stateFunc, 7}, - {CODING_NAME("aaa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 55, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aaa") Coding::stateFunc, 7 }, + { CODING_NAME("aaa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 55, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode32(x64Operand& operand) +asmError x64Parser::Opcode32(x64Operand &operand) { - operand.values[19] = OpcodeCodings32_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings32_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings33_19[] = { - {CODING_NAME("aad") Coding::stateFunc, 7}, - {CODING_NAME("aad")(Coding::Type)(Coding::valSpecified), 213, 0, 0, 0, 0}, - {CODING_NAME("aad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aad") Coding::stateFunc, 7 }, + { CODING_NAME("aad") (Coding::Type)(Coding::valSpecified), 213, 0, 0, 0, 0 }, + { CODING_NAME("aad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode33(x64Operand& operand) +asmError x64Parser::Opcode33(x64Operand &operand) { - operand.values[19] = OpcodeCodings33_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings33_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings34_19[] = { - {CODING_NAME("aam") Coding::stateFunc, 7}, - {CODING_NAME("aam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0}, - {CODING_NAME("aam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aam") Coding::stateFunc, 7 }, + { CODING_NAME("aam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, + { CODING_NAME("aam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode34(x64Operand& operand) +asmError x64Parser::Opcode34(x64Operand &operand) { - operand.values[19] = OpcodeCodings34_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings34_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings35_19[] = { - {CODING_NAME("aas") Coding::stateFunc, 7}, - {CODING_NAME("aas")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 63, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aas") Coding::stateFunc, 7 }, + { CODING_NAME("aas") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 63, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode35(x64Operand& operand) +asmError x64Parser::Opcode35(x64Operand &operand) { - operand.values[19] = OpcodeCodings35_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings35_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings36_18[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings36_36[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings36_37[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::valSpecified), 16, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::valSpecified), 16, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode36(x64Operand& operand) +asmError x64Parser::Opcode36(x64Operand &operand) { - operand.values[18] = OpcodeCodings36_18; - operand.values[36] = OpcodeCodings36_36; - operand.values[37] = OpcodeCodings36_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings36_18; + operand.values[36] = OpcodeCodings36_36; + operand.values[37] = OpcodeCodings36_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings37_18[] = { - {CODING_NAME("add")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings37_36[] = { - {CODING_NAME("add")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings37_37[] = { - {CODING_NAME("add")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode37(x64Operand& operand) +asmError x64Parser::Opcode37(x64Operand &operand) { - operand.values[18] = OpcodeCodings37_18; - operand.values[36] = OpcodeCodings37_36; - operand.values[37] = OpcodeCodings37_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings37_18; + operand.values[36] = OpcodeCodings37_36; + operand.values[37] = OpcodeCodings37_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings38_18[] = { - {CODING_NAME("and")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings38_36[] = { - {CODING_NAME("and")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings38_37[] = { - {CODING_NAME("and")(Coding::Type)(Coding::valSpecified), 32, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::valSpecified), 32, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode38(x64Operand& operand) +asmError x64Parser::Opcode38(x64Operand &operand) { - operand.values[18] = OpcodeCodings38_18; - operand.values[36] = OpcodeCodings38_36; - operand.values[37] = OpcodeCodings38_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings38_18; + operand.values[36] = OpcodeCodings38_36; + operand.values[37] = OpcodeCodings38_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode39(x64Operand& operand) +asmError x64Parser::Opcode39(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5862, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5862, operand); + return rv; } Coding x64Parser::OpcodeCodings40_36[] = { - {CODING_NAME("bound") Coding::stateFunc, 7}, - {CODING_NAME("bound")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bound") Coding::stateFunc, 7 }, + { CODING_NAME("bound") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode40(x64Operand& operand) +asmError x64Parser::Opcode40(x64Operand &operand) { - operand.values[36] = OpcodeCodings40_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings40_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings41_36[] = { - {CODING_NAME("bsf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bsf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 188, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bsf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bsf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 188, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode41(x64Operand& operand) +asmError x64Parser::Opcode41(x64Operand &operand) { - operand.values[36] = OpcodeCodings41_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings41_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings42_36[] = { - {CODING_NAME("bsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 189, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 189, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode42(x64Operand& operand) +asmError x64Parser::Opcode42(x64Operand &operand) { - operand.values[36] = OpcodeCodings42_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings42_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } -asmError x64Parser::Opcode43(x64Operand& operand) +asmError x64Parser::Opcode43(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5869, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5869, operand); + return rv; } Coding x64Parser::OpcodeCodings44_18[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings44_36[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings44_37[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode44(x64Operand& operand) +asmError x64Parser::Opcode44(x64Operand &operand) { - operand.values[18] = OpcodeCodings44_18; - operand.values[36] = OpcodeCodings44_36; - operand.values[37] = OpcodeCodings44_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings44_18; + operand.values[36] = OpcodeCodings44_36; + operand.values[37] = OpcodeCodings44_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings45_18[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings45_36[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings45_37[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 187, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 187, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode45(x64Operand& operand) +asmError x64Parser::Opcode45(x64Operand &operand) { - operand.values[18] = OpcodeCodings45_18; - operand.values[36] = OpcodeCodings45_36; - operand.values[37] = OpcodeCodings45_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings45_18; + operand.values[36] = OpcodeCodings45_36; + operand.values[37] = OpcodeCodings45_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings46_18[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings46_36[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings46_37[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 179, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 179, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode46(x64Operand& operand) +asmError x64Parser::Opcode46(x64Operand &operand) { - operand.values[18] = OpcodeCodings46_18; - operand.values[36] = OpcodeCodings46_36; - operand.values[37] = OpcodeCodings46_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings46_18; + operand.values[36] = OpcodeCodings46_36; + operand.values[37] = OpcodeCodings46_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings47_18[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings47_36[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings47_37[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode47(x64Operand& operand) +asmError x64Parser::Opcode47(x64Operand &operand) { - operand.values[18] = OpcodeCodings47_18; - operand.values[36] = OpcodeCodings47_36; - operand.values[37] = OpcodeCodings47_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings47_18; + operand.values[36] = OpcodeCodings47_36; + operand.values[37] = OpcodeCodings47_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } -asmError x64Parser::Opcode48(x64Operand& operand) +asmError x64Parser::Opcode48(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5876, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5876, operand); + return rv; } Coding x64Parser::OpcodeCodings49_19[] = { - {CODING_NAME("cbw") Coding::stateFunc, 4}, - {CODING_NAME("cbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cbw") Coding::stateFunc, 4 }, + { CODING_NAME("cbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode49(x64Operand& operand) +asmError x64Parser::Opcode49(x64Operand &operand) { - operand.values[19] = OpcodeCodings49_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings49_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings50_19[] = { - {CODING_NAME("cdq") Coding::stateFunc, 5}, - {CODING_NAME("cdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cdq") Coding::stateFunc, 5 }, + { CODING_NAME("cdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode50(x64Operand& operand) +asmError x64Parser::Opcode50(x64Operand &operand) { - operand.values[19] = OpcodeCodings50_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings50_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode51(x64Operand& operand) +asmError x64Parser::Opcode51(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5911, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5911, operand); + return rv; } Coding x64Parser::OpcodeCodings52_19[] = { - {CODING_NAME("clc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("clc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode52(x64Operand& operand) +asmError x64Parser::Opcode52(x64Operand &operand) { - operand.values[19] = OpcodeCodings52_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings52_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings53_19[] = { - {CODING_NAME("cld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode53(x64Operand& operand) +asmError x64Parser::Opcode53(x64Operand &operand) { - operand.values[19] = OpcodeCodings53_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings53_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings54_19[] = { - {CODING_NAME("cli")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cli") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode54(x64Operand& operand) +asmError x64Parser::Opcode54(x64Operand &operand) { - operand.values[19] = OpcodeCodings54_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings54_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings55_19[] = { - {CODING_NAME("clts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("clts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode55(x64Operand& operand) +asmError x64Parser::Opcode55(x64Operand &operand) { - operand.values[19] = OpcodeCodings55_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings55_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings56_19[] = { - {CODING_NAME("cmc")(Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmc") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode56(x64Operand& operand) +asmError x64Parser::Opcode56(x64Operand &operand) { - operand.values[19] = OpcodeCodings56_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings56_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings57_38[] = { - {CODING_NAME("cmova")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmova") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode57(x64Operand& operand) +asmError x64Parser::Opcode57(x64Operand &operand) { - operand.values[38] = OpcodeCodings57_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings57_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings58_38[] = { - {CODING_NAME("cmovae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode58(x64Operand& operand) +asmError x64Parser::Opcode58(x64Operand &operand) { - operand.values[38] = OpcodeCodings58_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings58_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings59_38[] = { - {CODING_NAME("cmovb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode59(x64Operand& operand) +asmError x64Parser::Opcode59(x64Operand &operand) { - operand.values[38] = OpcodeCodings59_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings59_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings60_38[] = { - {CODING_NAME("cmovbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode60(x64Operand& operand) +asmError x64Parser::Opcode60(x64Operand &operand) { - operand.values[38] = OpcodeCodings60_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings60_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings61_38[] = { - {CODING_NAME("cmovc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode61(x64Operand& operand) +asmError x64Parser::Opcode61(x64Operand &operand) { - operand.values[38] = OpcodeCodings61_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings61_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings62_38[] = { - {CODING_NAME("cmove")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmove") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode62(x64Operand& operand) +asmError x64Parser::Opcode62(x64Operand &operand) { - operand.values[38] = OpcodeCodings62_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings62_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings63_38[] = { - {CODING_NAME("cmovg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode63(x64Operand& operand) +asmError x64Parser::Opcode63(x64Operand &operand) { - operand.values[38] = OpcodeCodings63_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings63_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings64_38[] = { - {CODING_NAME("cmovge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode64(x64Operand& operand) +asmError x64Parser::Opcode64(x64Operand &operand) { - operand.values[38] = OpcodeCodings64_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings64_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings65_38[] = { - {CODING_NAME("cmovl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode65(x64Operand& operand) +asmError x64Parser::Opcode65(x64Operand &operand) { - operand.values[38] = OpcodeCodings65_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings65_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings66_38[] = { - {CODING_NAME("cmovle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode66(x64Operand& operand) +asmError x64Parser::Opcode66(x64Operand &operand) { - operand.values[38] = OpcodeCodings66_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings66_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings67_38[] = { - {CODING_NAME("cmovna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode67(x64Operand& operand) +asmError x64Parser::Opcode67(x64Operand &operand) { - operand.values[38] = OpcodeCodings67_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings67_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings68_38[] = { - {CODING_NAME("cmovnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode68(x64Operand& operand) +asmError x64Parser::Opcode68(x64Operand &operand) { - operand.values[38] = OpcodeCodings68_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings68_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings69_38[] = { - {CODING_NAME("cmovnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode69(x64Operand& operand) +asmError x64Parser::Opcode69(x64Operand &operand) { - operand.values[38] = OpcodeCodings69_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings69_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings70_38[] = { - {CODING_NAME("cmovnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode70(x64Operand& operand) +asmError x64Parser::Opcode70(x64Operand &operand) { - operand.values[38] = OpcodeCodings70_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings70_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings71_38[] = { - {CODING_NAME("cmovnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode71(x64Operand& operand) +asmError x64Parser::Opcode71(x64Operand &operand) { - operand.values[38] = OpcodeCodings71_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings71_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings72_38[] = { - {CODING_NAME("cmovne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode72(x64Operand& operand) +asmError x64Parser::Opcode72(x64Operand &operand) { - operand.values[38] = OpcodeCodings72_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings72_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings73_38[] = { - {CODING_NAME("cmovng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode73(x64Operand& operand) +asmError x64Parser::Opcode73(x64Operand &operand) { - operand.values[38] = OpcodeCodings73_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings73_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings74_38[] = { - {CODING_NAME("cmovnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode74(x64Operand& operand) +asmError x64Parser::Opcode74(x64Operand &operand) { - operand.values[38] = OpcodeCodings74_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings74_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings75_38[] = { - {CODING_NAME("cmovnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode75(x64Operand& operand) +asmError x64Parser::Opcode75(x64Operand &operand) { - operand.values[38] = OpcodeCodings75_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings75_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings76_38[] = { - {CODING_NAME("cmovnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode76(x64Operand& operand) +asmError x64Parser::Opcode76(x64Operand &operand) { - operand.values[38] = OpcodeCodings76_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings76_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings77_38[] = { - {CODING_NAME("cmovno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode77(x64Operand& operand) +asmError x64Parser::Opcode77(x64Operand &operand) { - operand.values[38] = OpcodeCodings77_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings77_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings78_38[] = { - {CODING_NAME("cmovnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode78(x64Operand& operand) +asmError x64Parser::Opcode78(x64Operand &operand) { - operand.values[38] = OpcodeCodings78_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings78_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings79_38[] = { - {CODING_NAME("cmovns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode79(x64Operand& operand) +asmError x64Parser::Opcode79(x64Operand &operand) { - operand.values[38] = OpcodeCodings79_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings79_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings80_38[] = { - {CODING_NAME("cmovnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode80(x64Operand& operand) +asmError x64Parser::Opcode80(x64Operand &operand) { - operand.values[38] = OpcodeCodings80_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings80_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings81_38[] = { - {CODING_NAME("cmovo")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode81(x64Operand& operand) +asmError x64Parser::Opcode81(x64Operand &operand) { - operand.values[38] = OpcodeCodings81_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings81_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings82_38[] = { - {CODING_NAME("cmovp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode82(x64Operand& operand) +asmError x64Parser::Opcode82(x64Operand &operand) { - operand.values[38] = OpcodeCodings82_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings82_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings83_38[] = { - {CODING_NAME("cmovpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode83(x64Operand& operand) +asmError x64Parser::Opcode83(x64Operand &operand) { - operand.values[38] = OpcodeCodings83_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings83_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings84_38[] = { - {CODING_NAME("cmovpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode84(x64Operand& operand) +asmError x64Parser::Opcode84(x64Operand &operand) { - operand.values[38] = OpcodeCodings84_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings84_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings85_38[] = { - {CODING_NAME("cmovs")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovs") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode85(x64Operand& operand) +asmError x64Parser::Opcode85(x64Operand &operand) { - operand.values[38] = OpcodeCodings85_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings85_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings86_38[] = { - {CODING_NAME("cmovz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode86(x64Operand& operand) +asmError x64Parser::Opcode86(x64Operand &operand) { - operand.values[38] = OpcodeCodings86_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings86_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings87_18[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings87_36[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 60, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 60, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings87_37[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::valSpecified), 56, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::valSpecified), 56, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode87(x64Operand& operand) +asmError x64Parser::Opcode87(x64Operand &operand) { - operand.values[18] = OpcodeCodings87_18; - operand.values[36] = OpcodeCodings87_36; - operand.values[37] = OpcodeCodings87_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings87_18; + operand.values[36] = OpcodeCodings87_36; + operand.values[37] = OpcodeCodings87_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode88(x64Operand& operand) +asmError x64Parser::Opcode88(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5949, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5949, operand); + return rv; } Coding x64Parser::OpcodeCodings89_19[] = { - {CODING_NAME("cmpsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode89(x64Operand& operand) +asmError x64Parser::Opcode89(x64Operand &operand) { - operand.values[19] = OpcodeCodings89_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings89_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings90_19[] = { - {CODING_NAME("cmpsw") Coding::stateFunc, 4}, - {CODING_NAME("cmpsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsw") Coding::stateFunc, 4 }, + { CODING_NAME("cmpsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode90(x64Operand& operand) +asmError x64Parser::Opcode90(x64Operand &operand) { - operand.values[19] = OpcodeCodings90_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings90_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings91_19[] = { - {CODING_NAME("cmpsd") Coding::stateFunc, 5}, - {CODING_NAME("cmpsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsd") Coding::stateFunc, 5 }, + { CODING_NAME("cmpsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode91(x64Operand& operand) +asmError x64Parser::Opcode91(x64Operand &operand) { - operand.values[19] = OpcodeCodings91_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings91_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode92(x64Operand& operand) +asmError x64Parser::Opcode92(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6217, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6217, operand); + return rv; } Coding x64Parser::OpcodeCodings93_36[] = { - {CODING_NAME("cmpxchg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmpxchg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 176, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpxchg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpxchg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 176, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode93(x64Operand& operand) +asmError x64Parser::Opcode93(x64Operand &operand) { - operand.values[36] = OpcodeCodings93_36; - asmError rv = ParseOperands(tokenBranches6219, operand); - return rv; + operand.values[36] = OpcodeCodings93_36; + asmError rv = ParseOperands(tokenBranches6219, operand); + return rv; } -asmError x64Parser::Opcode94(x64Operand& operand) +asmError x64Parser::Opcode94(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6240, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6240, operand); + return rv; } -asmError x64Parser::Opcode95(x64Operand& operand) +asmError x64Parser::Opcode95(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6242, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6242, operand); + return rv; } Coding x64Parser::OpcodeCodings96_19[] = { - {CODING_NAME("cpuid")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cpuid") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode96(x64Operand& operand) +asmError x64Parser::Opcode96(x64Operand &operand) { - operand.values[19] = OpcodeCodings96_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings96_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode97(x64Operand& operand) +asmError x64Parser::Opcode97(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6245, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6245, operand); + return rv; } Coding x64Parser::OpcodeCodings98_19[] = { - {CODING_NAME("cwd") Coding::stateFunc, 4}, - {CODING_NAME("cwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cwd") Coding::stateFunc, 4 }, + { CODING_NAME("cwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode98(x64Operand& operand) +asmError x64Parser::Opcode98(x64Operand &operand) { - operand.values[19] = OpcodeCodings98_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings98_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings99_19[] = { - {CODING_NAME("cwde") Coding::stateFunc, 5}, - {CODING_NAME("cwde")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cwde") Coding::stateFunc, 5 }, + { CODING_NAME("cwde") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode99(x64Operand& operand) +asmError x64Parser::Opcode99(x64Operand &operand) { - operand.values[19] = OpcodeCodings99_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings99_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings100_19[] = { - {CODING_NAME("daa") Coding::stateFunc, 7}, - {CODING_NAME("daa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("daa") Coding::stateFunc, 7 }, + { CODING_NAME("daa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode100(x64Operand& operand) +asmError x64Parser::Opcode100(x64Operand &operand) { - operand.values[19] = OpcodeCodings100_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings100_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings101_19[] = { - {CODING_NAME("das") Coding::stateFunc, 7}, - {CODING_NAME("das")(Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("das") Coding::stateFunc, 7 }, + { CODING_NAME("das") (Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode101(x64Operand& operand) +asmError x64Parser::Opcode101(x64Operand &operand) { - operand.values[19] = OpcodeCodings101_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings101_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings102_18[] = { - {CODING_NAME("dec")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings102_19[] = { - {CODING_NAME("dec")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode102(x64Operand& operand) +asmError x64Parser::Opcode102(x64Operand &operand) { - operand.values[18] = OpcodeCodings102_18; - operand.values[19] = OpcodeCodings102_19; - asmError rv; - { - rv = Opcode6(operand); - } - return rv; + operand.values[18] = OpcodeCodings102_18; + operand.values[19] = OpcodeCodings102_19; + asmError rv; + { + rv = Opcode6(operand); + } + return rv; } Coding x64Parser::OpcodeCodings103_18[] = { - {CODING_NAME("div")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("div") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode103(x64Operand& operand) +asmError x64Parser::Opcode103(x64Operand &operand) { - operand.values[18] = OpcodeCodings103_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings103_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } -asmError x64Parser::Opcode104(x64Operand& operand) +asmError x64Parser::Opcode104(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6253, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6253, operand); + return rv; } -asmError x64Parser::Opcode105(x64Operand& operand) +asmError x64Parser::Opcode105(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6259, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6259, operand); + return rv; } Coding x64Parser::OpcodeCodings106_19[] = { - {CODING_NAME("f2xm1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("f2xm1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode106(x64Operand& operand) +asmError x64Parser::Opcode106(x64Operand &operand) { - operand.values[19] = OpcodeCodings106_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings106_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings107_19[] = { - {CODING_NAME("fabs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fabs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode107(x64Operand& operand) +asmError x64Parser::Opcode107(x64Operand &operand) { - operand.values[19] = OpcodeCodings107_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings107_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings108_18[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings108_39[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings108_36[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode108(x64Operand& operand) +asmError x64Parser::Opcode108(x64Operand &operand) { - operand.values[18] = OpcodeCodings108_18; - operand.values[39] = OpcodeCodings108_39; - operand.values[36] = OpcodeCodings108_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings108_18; + operand.values[39] = OpcodeCodings108_39; + operand.values[36] = OpcodeCodings108_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings109_18[] = { - {CODING_NAME("faddp")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("faddp") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings109_19[] = { - {CODING_NAME("faddp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("faddp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode109(x64Operand& operand) +asmError x64Parser::Opcode109(x64Operand &operand) { - operand.values[18] = OpcodeCodings109_18; - operand.values[19] = OpcodeCodings109_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings109_18; + operand.values[19] = OpcodeCodings109_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings110_18[] = { - {CODING_NAME("fbld")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbld") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings110_19[] = { - {CODING_NAME("fbld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode110(x64Operand& operand) +asmError x64Parser::Opcode110(x64Operand &operand) { - operand.values[18] = OpcodeCodings110_18; - operand.values[19] = OpcodeCodings110_19; - asmError rv; - { - rv = Opcode11(operand); - } - return rv; + operand.values[18] = OpcodeCodings110_18; + operand.values[19] = OpcodeCodings110_19; + asmError rv; + { + rv = Opcode11(operand); + } + return rv; } Coding x64Parser::OpcodeCodings111_18[] = { - {CODING_NAME("fbstp")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbstp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings111_19[] = { - {CODING_NAME("fbstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode111(x64Operand& operand) +asmError x64Parser::Opcode111(x64Operand &operand) { - operand.values[18] = OpcodeCodings111_18; - operand.values[19] = OpcodeCodings111_19; - asmError rv; - { - rv = Opcode11(operand); - } - return rv; + operand.values[18] = OpcodeCodings111_18; + operand.values[19] = OpcodeCodings111_19; + asmError rv; + { + rv = Opcode11(operand); + } + return rv; } Coding x64Parser::OpcodeCodings112_19[] = { - {CODING_NAME("fchs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fchs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode112(x64Operand& operand) +asmError x64Parser::Opcode112(x64Operand &operand) { - operand.values[19] = OpcodeCodings112_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings112_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings113_19[] = { - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode113(x64Operand& operand) +asmError x64Parser::Opcode113(x64Operand &operand) { - operand.values[19] = OpcodeCodings113_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings113_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings114_19[] = { - {CODING_NAME("fnclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fnclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode114(x64Operand& operand) +asmError x64Parser::Opcode114(x64Operand &operand) { - operand.values[19] = OpcodeCodings114_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings114_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings115_18[] = { - {CODING_NAME("fcmovb")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings115_36[] = { - {CODING_NAME("fcmovb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode115(x64Operand& operand) +asmError x64Parser::Opcode115(x64Operand &operand) { - operand.values[18] = OpcodeCodings115_18; - operand.values[36] = OpcodeCodings115_36; - asmError rv = ParseOperands(tokenBranches6272, operand); - return rv; + operand.values[18] = OpcodeCodings115_18; + operand.values[36] = OpcodeCodings115_36; + asmError rv = ParseOperands(tokenBranches6272, operand); + return rv; } Coding x64Parser::OpcodeCodings116_18[] = { - {CODING_NAME("fcmovbe")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings116_36[] = { - {CODING_NAME("fcmovbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode116(x64Operand& operand) +asmError x64Parser::Opcode116(x64Operand &operand) { - operand.values[18] = OpcodeCodings116_18; - operand.values[36] = OpcodeCodings116_36; - asmError rv = ParseOperands(tokenBranches6276, operand); - return rv; + operand.values[18] = OpcodeCodings116_18; + operand.values[36] = OpcodeCodings116_36; + asmError rv = ParseOperands(tokenBranches6276, operand); + return rv; } Coding x64Parser::OpcodeCodings117_18[] = { - {CODING_NAME("fcmove")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings117_36[] = { - {CODING_NAME("fcmove")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode117(x64Operand& operand) +asmError x64Parser::Opcode117(x64Operand &operand) { - operand.values[18] = OpcodeCodings117_18; - operand.values[36] = OpcodeCodings117_36; - asmError rv = ParseOperands(tokenBranches6280, operand); - return rv; + operand.values[18] = OpcodeCodings117_18; + operand.values[36] = OpcodeCodings117_36; + asmError rv = ParseOperands(tokenBranches6280, operand); + return rv; } Coding x64Parser::OpcodeCodings118_18[] = { - {CODING_NAME("fcmovnb")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings118_36[] = { - {CODING_NAME("fcmovnb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode118(x64Operand& operand) +asmError x64Parser::Opcode118(x64Operand &operand) { - operand.values[18] = OpcodeCodings118_18; - operand.values[36] = OpcodeCodings118_36; - asmError rv = ParseOperands(tokenBranches6284, operand); - return rv; + operand.values[18] = OpcodeCodings118_18; + operand.values[36] = OpcodeCodings118_36; + asmError rv = ParseOperands(tokenBranches6284, operand); + return rv; } Coding x64Parser::OpcodeCodings119_18[] = { - {CODING_NAME("fcmovnbe")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings119_36[] = { - {CODING_NAME("fcmovnbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode119(x64Operand& operand) +asmError x64Parser::Opcode119(x64Operand &operand) { - operand.values[18] = OpcodeCodings119_18; - operand.values[36] = OpcodeCodings119_36; - asmError rv = ParseOperands(tokenBranches6288, operand); - return rv; + operand.values[18] = OpcodeCodings119_18; + operand.values[36] = OpcodeCodings119_36; + asmError rv = ParseOperands(tokenBranches6288, operand); + return rv; } Coding x64Parser::OpcodeCodings120_18[] = { - {CODING_NAME("fcmovne")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings120_36[] = { - {CODING_NAME("fcmovne")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode120(x64Operand& operand) +asmError x64Parser::Opcode120(x64Operand &operand) { - operand.values[18] = OpcodeCodings120_18; - operand.values[36] = OpcodeCodings120_36; - asmError rv = ParseOperands(tokenBranches6292, operand); - return rv; + operand.values[18] = OpcodeCodings120_18; + operand.values[36] = OpcodeCodings120_36; + asmError rv = ParseOperands(tokenBranches6292, operand); + return rv; } Coding x64Parser::OpcodeCodings121_18[] = { - {CODING_NAME("fcmovnu")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings121_36[] = { - {CODING_NAME("fcmovnu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode121(x64Operand& operand) +asmError x64Parser::Opcode121(x64Operand &operand) { - operand.values[18] = OpcodeCodings121_18; - operand.values[36] = OpcodeCodings121_36; - asmError rv = ParseOperands(tokenBranches6296, operand); - return rv; + operand.values[18] = OpcodeCodings121_18; + operand.values[36] = OpcodeCodings121_36; + asmError rv = ParseOperands(tokenBranches6296, operand); + return rv; } Coding x64Parser::OpcodeCodings122_18[] = { - {CODING_NAME("fcmovu")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings122_36[] = { - {CODING_NAME("fcmovu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode122(x64Operand& operand) +asmError x64Parser::Opcode122(x64Operand &operand) { - operand.values[18] = OpcodeCodings122_18; - operand.values[36] = OpcodeCodings122_36; - asmError rv = ParseOperands(tokenBranches6300, operand); - return rv; + operand.values[18] = OpcodeCodings122_18; + operand.values[36] = OpcodeCodings122_36; + asmError rv = ParseOperands(tokenBranches6300, operand); + return rv; } Coding x64Parser::OpcodeCodings123_18[] = { - {CODING_NAME("fcom")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings123_36[] = { - {CODING_NAME("fcom")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode123(x64Operand& operand) +asmError x64Parser::Opcode123(x64Operand &operand) { - operand.values[18] = OpcodeCodings123_18; - operand.values[36] = OpcodeCodings123_36; - asmError rv = ParseOperands(tokenBranches6304, operand); - return rv; + operand.values[18] = OpcodeCodings123_18; + operand.values[36] = OpcodeCodings123_36; + asmError rv = ParseOperands(tokenBranches6304, operand); + return rv; } Coding x64Parser::OpcodeCodings124_18[] = { - {CODING_NAME("fcomi")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings124_36[] = { - {CODING_NAME("fcomi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode124(x64Operand& operand) +asmError x64Parser::Opcode124(x64Operand &operand) { - operand.values[18] = OpcodeCodings124_18; - operand.values[36] = OpcodeCodings124_36; - asmError rv = ParseOperands(tokenBranches6313, operand); - return rv; + operand.values[18] = OpcodeCodings124_18; + operand.values[36] = OpcodeCodings124_36; + asmError rv = ParseOperands(tokenBranches6313, operand); + return rv; } Coding x64Parser::OpcodeCodings125_18[] = { - {CODING_NAME("fcomip")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings125_36[] = { - {CODING_NAME("fcomip")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode125(x64Operand& operand) +asmError x64Parser::Opcode125(x64Operand &operand) { - operand.values[18] = OpcodeCodings125_18; - operand.values[36] = OpcodeCodings125_36; - asmError rv = ParseOperands(tokenBranches6317, operand); - return rv; + operand.values[18] = OpcodeCodings125_18; + operand.values[36] = OpcodeCodings125_36; + asmError rv = ParseOperands(tokenBranches6317, operand); + return rv; } Coding x64Parser::OpcodeCodings126_18[] = { - {CODING_NAME("fcomp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings126_36[] = { - {CODING_NAME("fcomp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode126(x64Operand& operand) +asmError x64Parser::Opcode126(x64Operand &operand) { - operand.values[18] = OpcodeCodings126_18; - operand.values[36] = OpcodeCodings126_36; - asmError rv = ParseOperands(tokenBranches6321, operand); - return rv; + operand.values[18] = OpcodeCodings126_18; + operand.values[36] = OpcodeCodings126_36; + asmError rv = ParseOperands(tokenBranches6321, operand); + return rv; } Coding x64Parser::OpcodeCodings127_19[] = { - {CODING_NAME("fcompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("fcompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode127(x64Operand& operand) +asmError x64Parser::Opcode127(x64Operand &operand) { - operand.values[19] = OpcodeCodings127_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings127_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings128_19[] = { - {CODING_NAME("fcos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fcos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode128(x64Operand& operand) +asmError x64Parser::Opcode128(x64Operand &operand) { - operand.values[19] = OpcodeCodings128_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings128_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings129_19[] = { - {CODING_NAME("fdecstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fdecstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode129(x64Operand& operand) +asmError x64Parser::Opcode129(x64Operand &operand) { - operand.values[19] = OpcodeCodings129_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings129_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings130_19[] = { - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode130(x64Operand& operand) +asmError x64Parser::Opcode130(x64Operand &operand) { - operand.values[19] = OpcodeCodings130_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings130_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings131_18[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings131_39[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings131_36[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode131(x64Operand& operand) +asmError x64Parser::Opcode131(x64Operand &operand) { - operand.values[18] = OpcodeCodings131_18; - operand.values[39] = OpcodeCodings131_39; - operand.values[36] = OpcodeCodings131_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings131_18; + operand.values[39] = OpcodeCodings131_39; + operand.values[36] = OpcodeCodings131_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings132_18[] = { - {CODING_NAME("fdivp")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings132_19[] = { - {CODING_NAME("fdivp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode132(x64Operand& operand) +asmError x64Parser::Opcode132(x64Operand &operand) { - operand.values[18] = OpcodeCodings132_18; - operand.values[19] = OpcodeCodings132_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings132_18; + operand.values[19] = OpcodeCodings132_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings133_18[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings133_39[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings133_36[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode133(x64Operand& operand) +asmError x64Parser::Opcode133(x64Operand &operand) { - operand.values[18] = OpcodeCodings133_18; - operand.values[39] = OpcodeCodings133_39; - operand.values[36] = OpcodeCodings133_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings133_18; + operand.values[39] = OpcodeCodings133_39; + operand.values[36] = OpcodeCodings133_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings134_18[] = { - {CODING_NAME("fdivrp")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivrp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings134_19[] = { - {CODING_NAME("fdivrp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode134(x64Operand& operand) +asmError x64Parser::Opcode134(x64Operand &operand) { - operand.values[18] = OpcodeCodings134_18; - operand.values[19] = OpcodeCodings134_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings134_18; + operand.values[19] = OpcodeCodings134_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings135_19[] = { - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode135(x64Operand& operand) +asmError x64Parser::Opcode135(x64Operand &operand) { - operand.values[19] = OpcodeCodings135_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings135_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode136(x64Operand& operand) +asmError x64Parser::Opcode136(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6336, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6336, operand); + return rv; } -asmError x64Parser::Opcode137(x64Operand& operand) +asmError x64Parser::Opcode137(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6338, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6338, operand); + return rv; } Coding x64Parser::OpcodeCodings138_18[] = { - {CODING_NAME("fiadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fiadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings138_36[] = { - {CODING_NAME("fiadd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fiadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode138(x64Operand& operand) +asmError x64Parser::Opcode138(x64Operand &operand) { - operand.values[18] = OpcodeCodings138_18; - operand.values[36] = OpcodeCodings138_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings138_18; + operand.values[36] = OpcodeCodings138_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings139_18[] = { - {CODING_NAME("ficom")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings139_36[] = { - {CODING_NAME("ficom")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode139(x64Operand& operand) +asmError x64Parser::Opcode139(x64Operand &operand) { - operand.values[18] = OpcodeCodings139_18; - operand.values[36] = OpcodeCodings139_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings139_18; + operand.values[36] = OpcodeCodings139_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings140_18[] = { - {CODING_NAME("ficomp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings140_36[] = { - {CODING_NAME("ficomp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode140(x64Operand& operand) +asmError x64Parser::Opcode140(x64Operand &operand) { - operand.values[18] = OpcodeCodings140_18; - operand.values[36] = OpcodeCodings140_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings140_18; + operand.values[36] = OpcodeCodings140_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings141_18[] = { - {CODING_NAME("fidiv")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings141_36[] = { - {CODING_NAME("fidiv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode141(x64Operand& operand) +asmError x64Parser::Opcode141(x64Operand &operand) { - operand.values[18] = OpcodeCodings141_18; - operand.values[36] = OpcodeCodings141_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings141_18; + operand.values[36] = OpcodeCodings141_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings142_18[] = { - {CODING_NAME("fidivr")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings142_36[] = { - {CODING_NAME("fidivr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode142(x64Operand& operand) +asmError x64Parser::Opcode142(x64Operand &operand) { - operand.values[18] = OpcodeCodings142_18; - operand.values[36] = OpcodeCodings142_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings142_18; + operand.values[36] = OpcodeCodings142_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings143_18[] = { - {CODING_NAME("fild")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fild") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings143_36[] = { - {CODING_NAME("fild")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fild") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode143(x64Operand& operand) +asmError x64Parser::Opcode143(x64Operand &operand) { - operand.values[18] = OpcodeCodings143_18; - operand.values[36] = OpcodeCodings143_36; - asmError rv = ParseOperands(tokenBranches6345, operand); - return rv; + operand.values[18] = OpcodeCodings143_18; + operand.values[36] = OpcodeCodings143_36; + asmError rv = ParseOperands(tokenBranches6345, operand); + return rv; } Coding x64Parser::OpcodeCodings144_18[] = { - {CODING_NAME("fimul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fimul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings144_36[] = { - {CODING_NAME("fimul")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fimul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode144(x64Operand& operand) +asmError x64Parser::Opcode144(x64Operand &operand) { - operand.values[18] = OpcodeCodings144_18; - operand.values[36] = OpcodeCodings144_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings144_18; + operand.values[36] = OpcodeCodings144_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings145_19[] = { - {CODING_NAME("fincstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fincstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode145(x64Operand& operand) +asmError x64Parser::Opcode145(x64Operand &operand) { - operand.values[19] = OpcodeCodings145_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings145_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings146_19[] = { - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode146(x64Operand& operand) +asmError x64Parser::Opcode146(x64Operand &operand) { - operand.values[19] = OpcodeCodings146_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings146_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings147_19[] = { - {CODING_NAME("fninit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fninit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode147(x64Operand& operand) +asmError x64Parser::Opcode147(x64Operand &operand) { - operand.values[19] = OpcodeCodings147_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings147_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings148_18[] = { - {CODING_NAME("fist")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fist") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings148_36[] = { - {CODING_NAME("fist")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fist") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode148(x64Operand& operand) +asmError x64Parser::Opcode148(x64Operand &operand) { - operand.values[18] = OpcodeCodings148_18; - operand.values[36] = OpcodeCodings148_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings148_18; + operand.values[36] = OpcodeCodings148_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings149_18[] = { - {CODING_NAME("fistp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fistp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings149_36[] = { - {CODING_NAME("fistp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fistp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode149(x64Operand& operand) +asmError x64Parser::Opcode149(x64Operand &operand) { - operand.values[18] = OpcodeCodings149_18; - operand.values[36] = OpcodeCodings149_36; - asmError rv = ParseOperands(tokenBranches6357, operand); - return rv; + operand.values[18] = OpcodeCodings149_18; + operand.values[36] = OpcodeCodings149_36; + asmError rv = ParseOperands(tokenBranches6357, operand); + return rv; } Coding x64Parser::OpcodeCodings150_18[] = { - {CODING_NAME("fisub")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings150_36[] = { - {CODING_NAME("fisub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode150(x64Operand& operand) +asmError x64Parser::Opcode150(x64Operand &operand) { - operand.values[18] = OpcodeCodings150_18; - operand.values[36] = OpcodeCodings150_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings150_18; + operand.values[36] = OpcodeCodings150_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings151_18[] = { - {CODING_NAME("fisubr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings151_36[] = { - {CODING_NAME("fisubr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode151(x64Operand& operand) +asmError x64Parser::Opcode151(x64Operand &operand) { - operand.values[18] = OpcodeCodings151_18; - operand.values[36] = OpcodeCodings151_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings151_18; + operand.values[36] = OpcodeCodings151_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } -asmError x64Parser::Opcode152(x64Operand& operand) +asmError x64Parser::Opcode152(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6364, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6364, operand); + return rv; } Coding x64Parser::OpcodeCodings153_19[] = { - {CODING_NAME("fld1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fld1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode153(x64Operand& operand) +asmError x64Parser::Opcode153(x64Operand &operand) { - operand.values[19] = OpcodeCodings153_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings153_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode154(x64Operand& operand) +asmError x64Parser::Opcode154(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6373, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6373, operand); + return rv; } -asmError x64Parser::Opcode155(x64Operand& operand) +asmError x64Parser::Opcode155(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6376, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6376, operand); + return rv; } Coding x64Parser::OpcodeCodings156_19[] = { - {CODING_NAME("fldl2e")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldl2e")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode156(x64Operand& operand) +asmError x64Parser::Opcode156(x64Operand &operand) { - operand.values[19] = OpcodeCodings156_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings156_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings157_19[] = { - {CODING_NAME("fldl2t")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldl2t")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode157(x64Operand& operand) +asmError x64Parser::Opcode157(x64Operand &operand) { - operand.values[19] = OpcodeCodings157_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings157_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings158_19[] = { - {CODING_NAME("fldlg2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldlg2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode158(x64Operand& operand) +asmError x64Parser::Opcode158(x64Operand &operand) { - operand.values[19] = OpcodeCodings158_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings158_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings159_19[] = { - {CODING_NAME("fldln2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldln2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode159(x64Operand& operand) +asmError x64Parser::Opcode159(x64Operand &operand) { - operand.values[19] = OpcodeCodings159_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings159_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings160_19[] = { - {CODING_NAME("fldpi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldpi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode160(x64Operand& operand) +asmError x64Parser::Opcode160(x64Operand &operand) { - operand.values[19] = OpcodeCodings160_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings160_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings161_19[] = { - {CODING_NAME("fldz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode161(x64Operand& operand) +asmError x64Parser::Opcode161(x64Operand &operand) { - operand.values[19] = OpcodeCodings161_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings161_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings162_18[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings162_39[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings162_36[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode162(x64Operand& operand) +asmError x64Parser::Opcode162(x64Operand &operand) { - operand.values[18] = OpcodeCodings162_18; - operand.values[39] = OpcodeCodings162_39; - operand.values[36] = OpcodeCodings162_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings162_18; + operand.values[39] = OpcodeCodings162_39; + operand.values[36] = OpcodeCodings162_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings163_18[] = { - {CODING_NAME("fmulp")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmulp") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings163_19[] = { - {CODING_NAME("fmulp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmulp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode163(x64Operand& operand) +asmError x64Parser::Opcode163(x64Operand &operand) { - operand.values[18] = OpcodeCodings163_18; - operand.values[19] = OpcodeCodings163_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings163_18; + operand.values[19] = OpcodeCodings163_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings164_19[] = { - {CODING_NAME("fnop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fnop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode164(x64Operand& operand) +asmError x64Parser::Opcode164(x64Operand &operand) { - operand.values[19] = OpcodeCodings164_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings164_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode165(x64Operand& operand) +asmError x64Parser::Opcode165(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6387, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6387, operand); + return rv; } Coding x64Parser::OpcodeCodings166_19[] = { - {CODING_NAME("fpatan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fpatan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode166(x64Operand& operand) +asmError x64Parser::Opcode166(x64Operand &operand) { - operand.values[19] = OpcodeCodings166_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings166_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings167_19[] = { - {CODING_NAME("fprem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fprem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode167(x64Operand& operand) +asmError x64Parser::Opcode167(x64Operand &operand) { - operand.values[19] = OpcodeCodings167_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings167_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings168_19[] = { - {CODING_NAME("fprem1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fprem1")(Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fprem1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fprem1") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode168(x64Operand& operand) +asmError x64Parser::Opcode168(x64Operand &operand) { - operand.values[19] = OpcodeCodings168_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings168_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings169_19[] = { - {CODING_NAME("fptan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fptan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode169(x64Operand& operand) +asmError x64Parser::Opcode169(x64Operand &operand) { - operand.values[19] = OpcodeCodings169_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings169_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings170_19[] = { - {CODING_NAME("frndint")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("frndint")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode170(x64Operand& operand) +asmError x64Parser::Opcode170(x64Operand &operand) { - operand.values[19] = OpcodeCodings170_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings170_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode171(x64Operand& operand) +asmError x64Parser::Opcode171(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6394, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6394, operand); + return rv; } -asmError x64Parser::Opcode172(x64Operand& operand) +asmError x64Parser::Opcode172(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6396, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6396, operand); + return rv; } Coding x64Parser::OpcodeCodings173_19[] = { - {CODING_NAME("fscale")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fscale")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode173(x64Operand& operand) +asmError x64Parser::Opcode173(x64Operand &operand) { - operand.values[19] = OpcodeCodings173_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings173_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings174_19[] = { - {CODING_NAME("fsetpm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fsetpm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode174(x64Operand& operand) +asmError x64Parser::Opcode174(x64Operand &operand) { - operand.values[19] = OpcodeCodings174_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings174_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings175_19[] = { - {CODING_NAME("fsin")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsin")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode175(x64Operand& operand) +asmError x64Parser::Opcode175(x64Operand &operand) { - operand.values[19] = OpcodeCodings175_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings175_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings176_19[] = { - {CODING_NAME("fsincos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsincos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode176(x64Operand& operand) +asmError x64Parser::Opcode176(x64Operand &operand) { - operand.values[19] = OpcodeCodings176_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings176_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings177_19[] = { - {CODING_NAME("fsqrt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsqrt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode177(x64Operand& operand) +asmError x64Parser::Opcode177(x64Operand &operand) { - operand.values[19] = OpcodeCodings177_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings177_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode178(x64Operand& operand) +asmError x64Parser::Opcode178(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6403, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6403, operand); + return rv; } -asmError x64Parser::Opcode179(x64Operand& operand) +asmError x64Parser::Opcode179(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6409, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6409, operand); + return rv; } -asmError x64Parser::Opcode180(x64Operand& operand) +asmError x64Parser::Opcode180(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6412, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6412, operand); + return rv; } -asmError x64Parser::Opcode181(x64Operand& operand) +asmError x64Parser::Opcode181(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6415, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6415, operand); + return rv; } -asmError x64Parser::Opcode182(x64Operand& operand) +asmError x64Parser::Opcode182(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6417, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6417, operand); + return rv; } -asmError x64Parser::Opcode183(x64Operand& operand) +asmError x64Parser::Opcode183(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6419, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6419, operand); + return rv; } -asmError x64Parser::Opcode184(x64Operand& operand) +asmError x64Parser::Opcode184(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6427, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6427, operand); + return rv; } -asmError x64Parser::Opcode185(x64Operand& operand) +asmError x64Parser::Opcode185(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6431, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6431, operand); + return rv; } Coding x64Parser::OpcodeCodings186_18[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings186_39[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings186_36[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode186(x64Operand& operand) +asmError x64Parser::Opcode186(x64Operand &operand) { - operand.values[18] = OpcodeCodings186_18; - operand.values[39] = OpcodeCodings186_39; - operand.values[36] = OpcodeCodings186_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings186_18; + operand.values[39] = OpcodeCodings186_39; + operand.values[36] = OpcodeCodings186_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings187_18[] = { - {CODING_NAME("fsubp")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings187_19[] = { - {CODING_NAME("fsubp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode187(x64Operand& operand) +asmError x64Parser::Opcode187(x64Operand &operand) { - operand.values[18] = OpcodeCodings187_18; - operand.values[19] = OpcodeCodings187_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings187_18; + operand.values[19] = OpcodeCodings187_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings188_18[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings188_39[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings188_36[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode188(x64Operand& operand) +asmError x64Parser::Opcode188(x64Operand &operand) { - operand.values[18] = OpcodeCodings188_18; - operand.values[39] = OpcodeCodings188_39; - operand.values[36] = OpcodeCodings188_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings188_18; + operand.values[39] = OpcodeCodings188_39; + operand.values[36] = OpcodeCodings188_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings189_18[] = { - {CODING_NAME("fsubrp")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubrp") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings189_19[] = { - {CODING_NAME("fsubrp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode189(x64Operand& operand) +asmError x64Parser::Opcode189(x64Operand &operand) { - operand.values[18] = OpcodeCodings189_18; - operand.values[19] = OpcodeCodings189_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings189_18; + operand.values[19] = OpcodeCodings189_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings190_19[] = { - {CODING_NAME("ftst")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("ftst")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode190(x64Operand& operand) +asmError x64Parser::Opcode190(x64Operand &operand) { - operand.values[19] = OpcodeCodings190_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings190_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings191_18[] = { - {CODING_NAME("fucom")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings191_19[] = { - {CODING_NAME("fucom")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode191(x64Operand& operand) +asmError x64Parser::Opcode191(x64Operand &operand) { - operand.values[18] = OpcodeCodings191_18; - operand.values[19] = OpcodeCodings191_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings191_18; + operand.values[19] = OpcodeCodings191_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings192_18[] = { - {CODING_NAME("fucomi")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomi") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings192_36[] = { - {CODING_NAME("fucomi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode192(x64Operand& operand) +asmError x64Parser::Opcode192(x64Operand &operand) { - operand.values[18] = OpcodeCodings192_18; - operand.values[36] = OpcodeCodings192_36; - asmError rv = ParseOperands(tokenBranches6441, operand); - return rv; + operand.values[18] = OpcodeCodings192_18; + operand.values[36] = OpcodeCodings192_36; + asmError rv = ParseOperands(tokenBranches6441, operand); + return rv; } Coding x64Parser::OpcodeCodings193_18[] = { - {CODING_NAME("fucomip")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomip") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings193_36[] = { - {CODING_NAME("fucomip")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode193(x64Operand& operand) +asmError x64Parser::Opcode193(x64Operand &operand) { - operand.values[18] = OpcodeCodings193_18; - operand.values[36] = OpcodeCodings193_36; - asmError rv = ParseOperands(tokenBranches6445, operand); - return rv; + operand.values[18] = OpcodeCodings193_18; + operand.values[36] = OpcodeCodings193_36; + asmError rv = ParseOperands(tokenBranches6445, operand); + return rv; } Coding x64Parser::OpcodeCodings194_18[] = { - {CODING_NAME("fucomp")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings194_19[] = { - {CODING_NAME("fucomp")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode194(x64Operand& operand) +asmError x64Parser::Opcode194(x64Operand &operand) { - operand.values[18] = OpcodeCodings194_18; - operand.values[19] = OpcodeCodings194_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings194_18; + operand.values[19] = OpcodeCodings194_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings195_19[] = { - {CODING_NAME("fucompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("fucompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode195(x64Operand& operand) +asmError x64Parser::Opcode195(x64Operand &operand) { - operand.values[19] = OpcodeCodings195_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings195_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings196_19[] = { - {CODING_NAME("fwait")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fwait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode196(x64Operand& operand) +asmError x64Parser::Opcode196(x64Operand &operand) { - operand.values[19] = OpcodeCodings196_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings196_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings197_19[] = { - {CODING_NAME("fxam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fxam")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fxam") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode197(x64Operand& operand) +asmError x64Parser::Opcode197(x64Operand &operand) { - operand.values[19] = OpcodeCodings197_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings197_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings198_18[] = { - {CODING_NAME("fxch")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings198_19[] = { - {CODING_NAME("fxch")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode198(x64Operand& operand) +asmError x64Parser::Opcode198(x64Operand &operand) { - operand.values[18] = OpcodeCodings198_18; - operand.values[19] = OpcodeCodings198_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings198_18; + operand.values[19] = OpcodeCodings198_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings199_18[] = { - {CODING_NAME("fxch4")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch4") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings199_36[] = { - {CODING_NAME("fxch4")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch4") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode199(x64Operand& operand) +asmError x64Parser::Opcode199(x64Operand &operand) { - operand.values[18] = OpcodeCodings199_18; - operand.values[36] = OpcodeCodings199_36; - asmError rv = ParseOperands(tokenBranches6454, operand); - return rv; + operand.values[18] = OpcodeCodings199_18; + operand.values[36] = OpcodeCodings199_36; + asmError rv = ParseOperands(tokenBranches6454, operand); + return rv; } Coding x64Parser::OpcodeCodings200_18[] = { - {CODING_NAME("fxch7")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch7") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings200_36[] = { - {CODING_NAME("fxch7")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch7") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode200(x64Operand& operand) +asmError x64Parser::Opcode200(x64Operand &operand) { - operand.values[18] = OpcodeCodings200_18; - operand.values[36] = OpcodeCodings200_36; - asmError rv = ParseOperands(tokenBranches6458, operand); - return rv; + operand.values[18] = OpcodeCodings200_18; + operand.values[36] = OpcodeCodings200_36; + asmError rv = ParseOperands(tokenBranches6458, operand); + return rv; } -asmError x64Parser::Opcode201(x64Operand& operand) +asmError x64Parser::Opcode201(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6462, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6462, operand); + return rv; } -asmError x64Parser::Opcode202(x64Operand& operand) +asmError x64Parser::Opcode202(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6464, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6464, operand); + return rv; } Coding x64Parser::OpcodeCodings203_19[] = { - {CODING_NAME("fxtract")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fxtract")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode203(x64Operand& operand) +asmError x64Parser::Opcode203(x64Operand &operand) { - operand.values[19] = OpcodeCodings203_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings203_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings204_19[] = { - {CODING_NAME("fyl2x")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fyl2x")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode204(x64Operand& operand) +asmError x64Parser::Opcode204(x64Operand &operand) { - operand.values[19] = OpcodeCodings204_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings204_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings205_19[] = { - {CODING_NAME("fyl2xp1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fyl2xp1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode205(x64Operand& operand) +asmError x64Parser::Opcode205(x64Operand &operand) { - operand.values[19] = OpcodeCodings205_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings205_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings206_19[] = { - {CODING_NAME("hlt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hlt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode206(x64Operand& operand) +asmError x64Parser::Opcode206(x64Operand &operand) { - operand.values[19] = OpcodeCodings206_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings206_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings207_19[] = { - {CODING_NAME("icebp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("icebp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode207(x64Operand& operand) +asmError x64Parser::Opcode207(x64Operand &operand) { - operand.values[19] = OpcodeCodings207_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings207_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings208_18[] = { - {CODING_NAME("idiv")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("idiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode208(x64Operand& operand) +asmError x64Parser::Opcode208(x64Operand &operand) { - operand.values[18] = OpcodeCodings208_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings208_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } -asmError x64Parser::Opcode209(x64Operand& operand) +asmError x64Parser::Opcode209(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6472, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6472, operand); + return rv; } -asmError x64Parser::Opcode210(x64Operand& operand) +asmError x64Parser::Opcode210(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6556, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6556, operand); + return rv; } -asmError x64Parser::Opcode211(x64Operand& operand) +asmError x64Parser::Opcode211(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6585, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6585, operand); + return rv; } Coding x64Parser::OpcodeCodings212_19[] = { - {CODING_NAME("insb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode212(x64Operand& operand) +asmError x64Parser::Opcode212(x64Operand &operand) { - operand.values[19] = OpcodeCodings212_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings212_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings213_19[] = { - {CODING_NAME("insw") Coding::stateFunc, 4}, - {CODING_NAME("insw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insw") Coding::stateFunc, 4 }, + { CODING_NAME("insw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode213(x64Operand& operand) +asmError x64Parser::Opcode213(x64Operand &operand) { - operand.values[19] = OpcodeCodings213_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings213_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings214_19[] = { - {CODING_NAME("insd") Coding::stateFunc, 5}, - {CODING_NAME("insd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insd") Coding::stateFunc, 5 }, + { CODING_NAME("insd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode214(x64Operand& operand) +asmError x64Parser::Opcode214(x64Operand &operand) { - operand.values[19] = OpcodeCodings214_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings214_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings215_18[] = { - {CODING_NAME("inc")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings215_19[] = { - {CODING_NAME("inc")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode215(x64Operand& operand) +asmError x64Parser::Opcode215(x64Operand &operand) { - operand.values[18] = OpcodeCodings215_18; - operand.values[19] = OpcodeCodings215_19; - asmError rv; - { - rv = Opcode6(operand); - } - return rv; + operand.values[18] = OpcodeCodings215_18; + operand.values[19] = OpcodeCodings215_19; + asmError rv; + { + rv = Opcode6(operand); + } + return rv; } -asmError x64Parser::Opcode216(x64Operand& operand) +asmError x64Parser::Opcode216(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6728, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6728, operand); + return rv; } Coding x64Parser::OpcodeCodings217_19[] = { - {CODING_NAME("int1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("int1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode217(x64Operand& operand) +asmError x64Parser::Opcode217(x64Operand &operand) { - operand.values[19] = OpcodeCodings217_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings217_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings218_19[] = { - {CODING_NAME("int3")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("int3") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode218(x64Operand& operand) +asmError x64Parser::Opcode218(x64Operand &operand) { - operand.values[19] = OpcodeCodings218_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings218_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings219_19[] = { - {CODING_NAME("into")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("into") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode219(x64Operand& operand) +asmError x64Parser::Opcode219(x64Operand &operand) { - operand.values[19] = OpcodeCodings219_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings219_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings220_19[] = { - {CODING_NAME("invd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("invd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode220(x64Operand& operand) +asmError x64Parser::Opcode220(x64Operand &operand) { - operand.values[19] = OpcodeCodings220_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings220_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode221(x64Operand& operand) +asmError x64Parser::Opcode221(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6735, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6735, operand); + return rv; } Coding x64Parser::OpcodeCodings222_19[] = { - {CODING_NAME("iret")(Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iret") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode222(x64Operand& operand) +asmError x64Parser::Opcode222(x64Operand &operand) { - operand.values[19] = OpcodeCodings222_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings222_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings223_19[] = { - {CODING_NAME("iretw") Coding::stateFunc, 4}, - {CODING_NAME("iretw")(Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iretw") Coding::stateFunc, 4 }, + { CODING_NAME("iretw") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode223(x64Operand& operand) +asmError x64Parser::Opcode223(x64Operand &operand) { - operand.values[19] = OpcodeCodings223_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings223_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode224(x64Operand& operand) +asmError x64Parser::Opcode224(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6739, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6739, operand); + return rv; } Coding x64Parser::OpcodeCodings225_19[] = { - {CODING_NAME("iretq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("iretq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode225(x64Operand& operand) +asmError x64Parser::Opcode225(x64Operand &operand) { - operand.values[19] = OpcodeCodings225_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings225_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings226_38[] = { - {CODING_NAME("ja")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ja") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode226(x64Operand& operand) +asmError x64Parser::Opcode226(x64Operand &operand) { - operand.values[38] = OpcodeCodings226_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings226_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings227_38[] = { - {CODING_NAME("jae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode227(x64Operand& operand) +asmError x64Parser::Opcode227(x64Operand &operand) { - operand.values[38] = OpcodeCodings227_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings227_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings228_38[] = { - {CODING_NAME("jb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode228(x64Operand& operand) +asmError x64Parser::Opcode228(x64Operand &operand) { - operand.values[38] = OpcodeCodings228_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings228_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings229_38[] = { - {CODING_NAME("jbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode229(x64Operand& operand) +asmError x64Parser::Opcode229(x64Operand &operand) { - operand.values[38] = OpcodeCodings229_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings229_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings230_38[] = { - {CODING_NAME("jc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode230(x64Operand& operand) +asmError x64Parser::Opcode230(x64Operand &operand) { - operand.values[38] = OpcodeCodings230_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings230_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } -asmError x64Parser::Opcode231(x64Operand& operand) +asmError x64Parser::Opcode231(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6747, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6747, operand); + return rv; } -asmError x64Parser::Opcode232(x64Operand& operand) +asmError x64Parser::Opcode232(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6749, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6749, operand); + return rv; } Coding x64Parser::OpcodeCodings233_38[] = { - {CODING_NAME("je")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode233(x64Operand& operand) +asmError x64Parser::Opcode233(x64Operand &operand) { - operand.values[38] = OpcodeCodings233_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings233_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings234_38[] = { - {CODING_NAME("jg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode234(x64Operand& operand) +asmError x64Parser::Opcode234(x64Operand &operand) { - operand.values[38] = OpcodeCodings234_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings234_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings235_38[] = { - {CODING_NAME("jge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode235(x64Operand& operand) +asmError x64Parser::Opcode235(x64Operand &operand) { - operand.values[38] = OpcodeCodings235_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings235_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings236_38[] = { - {CODING_NAME("jl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode236(x64Operand& operand) +asmError x64Parser::Opcode236(x64Operand &operand) { - operand.values[38] = OpcodeCodings236_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings236_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings237_38[] = { - {CODING_NAME("jle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode237(x64Operand& operand) +asmError x64Parser::Opcode237(x64Operand &operand) { - operand.values[38] = OpcodeCodings237_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings237_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } -asmError x64Parser::Opcode238(x64Operand& operand) +asmError x64Parser::Opcode238(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6756, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6756, operand); + return rv; } Coding x64Parser::OpcodeCodings239_38[] = { - {CODING_NAME("jna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode239(x64Operand& operand) +asmError x64Parser::Opcode239(x64Operand &operand) { - operand.values[38] = OpcodeCodings239_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings239_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings240_38[] = { - {CODING_NAME("jnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode240(x64Operand& operand) +asmError x64Parser::Opcode240(x64Operand &operand) { - operand.values[38] = OpcodeCodings240_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings240_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings241_38[] = { - {CODING_NAME("jnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode241(x64Operand& operand) +asmError x64Parser::Opcode241(x64Operand &operand) { - operand.values[38] = OpcodeCodings241_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings241_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings242_38[] = { - {CODING_NAME("jnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode242(x64Operand& operand) +asmError x64Parser::Opcode242(x64Operand &operand) { - operand.values[38] = OpcodeCodings242_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings242_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings243_38[] = { - {CODING_NAME("jnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode243(x64Operand& operand) +asmError x64Parser::Opcode243(x64Operand &operand) { - operand.values[38] = OpcodeCodings243_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings243_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings244_38[] = { - {CODING_NAME("jne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode244(x64Operand& operand) +asmError x64Parser::Opcode244(x64Operand &operand) { - operand.values[38] = OpcodeCodings244_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings244_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings245_38[] = { - {CODING_NAME("jng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode245(x64Operand& operand) +asmError x64Parser::Opcode245(x64Operand &operand) { - operand.values[38] = OpcodeCodings245_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings245_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings246_38[] = { - {CODING_NAME("jnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode246(x64Operand& operand) +asmError x64Parser::Opcode246(x64Operand &operand) { - operand.values[38] = OpcodeCodings246_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings246_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings247_38[] = { - {CODING_NAME("jnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode247(x64Operand& operand) +asmError x64Parser::Opcode247(x64Operand &operand) { - operand.values[38] = OpcodeCodings247_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings247_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings248_38[] = { - {CODING_NAME("jnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode248(x64Operand& operand) +asmError x64Parser::Opcode248(x64Operand &operand) { - operand.values[38] = OpcodeCodings248_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings248_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings249_38[] = { - {CODING_NAME("jno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode249(x64Operand& operand) +asmError x64Parser::Opcode249(x64Operand &operand) { - operand.values[38] = OpcodeCodings249_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings249_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings250_38[] = { - {CODING_NAME("jnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode250(x64Operand& operand) +asmError x64Parser::Opcode250(x64Operand &operand) { - operand.values[38] = OpcodeCodings250_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings250_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings251_38[] = { - {CODING_NAME("jns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode251(x64Operand& operand) +asmError x64Parser::Opcode251(x64Operand &operand) { - operand.values[38] = OpcodeCodings251_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings251_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings252_38[] = { - {CODING_NAME("jnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode252(x64Operand& operand) +asmError x64Parser::Opcode252(x64Operand &operand) { - operand.values[38] = OpcodeCodings252_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings252_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings253_38[] = { - {CODING_NAME("jo")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode253(x64Operand& operand) +asmError x64Parser::Opcode253(x64Operand &operand) { - operand.values[38] = OpcodeCodings253_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings253_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings254_38[] = { - {CODING_NAME("jp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode254(x64Operand& operand) +asmError x64Parser::Opcode254(x64Operand &operand) { - operand.values[38] = OpcodeCodings254_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings254_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings255_38[] = { - {CODING_NAME("jpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode255(x64Operand& operand) +asmError x64Parser::Opcode255(x64Operand &operand) { - operand.values[38] = OpcodeCodings255_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings255_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings256_38[] = { - {CODING_NAME("jpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode256(x64Operand& operand) +asmError x64Parser::Opcode256(x64Operand &operand) { - operand.values[38] = OpcodeCodings256_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings256_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings257_38[] = { - {CODING_NAME("js")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode257(x64Operand& operand) +asmError x64Parser::Opcode257(x64Operand &operand) { - operand.values[38] = OpcodeCodings257_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings257_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings258_38[] = { - {CODING_NAME("jz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode258(x64Operand& operand) +asmError x64Parser::Opcode258(x64Operand &operand) { - operand.values[38] = OpcodeCodings258_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings258_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings259_19[] = { - {CODING_NAME("lahf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode259(x64Operand& operand) +asmError x64Parser::Opcode259(x64Operand &operand) { - operand.values[19] = OpcodeCodings259_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings259_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings260_36[] = { - {CODING_NAME("lar")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lar")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode260(x64Operand& operand) +asmError x64Parser::Opcode260(x64Operand &operand) { - operand.values[36] = OpcodeCodings260_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings260_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings261_36[] = { - {CODING_NAME("lds") Coding::stateFunc, 7}, - {CODING_NAME("lds")(Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lds") Coding::stateFunc, 7 }, + { CODING_NAME("lds") (Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode261(x64Operand& operand) +asmError x64Parser::Opcode261(x64Operand &operand) { - operand.values[36] = OpcodeCodings261_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings261_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings262_36[] = { - {CODING_NAME("lea")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lea") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode262(x64Operand& operand) +asmError x64Parser::Opcode262(x64Operand &operand) { - operand.values[36] = OpcodeCodings262_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings262_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings263_19[] = { - {CODING_NAME("leave")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("leave") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode263(x64Operand& operand) +asmError x64Parser::Opcode263(x64Operand &operand) { - operand.values[19] = OpcodeCodings263_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings263_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings264_36[] = { - {CODING_NAME("les") Coding::stateFunc, 7}, - {CODING_NAME("les")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("les") Coding::stateFunc, 7 }, + { CODING_NAME("les") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode264(x64Operand& operand) +asmError x64Parser::Opcode264(x64Operand &operand) { - operand.values[36] = OpcodeCodings264_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings264_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings265_19[] = { - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode265(x64Operand& operand) +asmError x64Parser::Opcode265(x64Operand &operand) { - operand.values[19] = OpcodeCodings265_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings265_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings266_36[] = { - {CODING_NAME("lfs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lfs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode266(x64Operand& operand) +asmError x64Parser::Opcode266(x64Operand &operand) { - operand.values[36] = OpcodeCodings266_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings266_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings267_18[] = { - {CODING_NAME("lgdt")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgdt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings267_19[] = { - {CODING_NAME("lgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode267(x64Operand& operand) +asmError x64Parser::Opcode267(x64Operand &operand) { - operand.values[18] = OpcodeCodings267_18; - operand.values[19] = OpcodeCodings267_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings267_18; + operand.values[19] = OpcodeCodings267_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings268_36[] = { - {CODING_NAME("lgs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lgs")(Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lgs") (Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode268(x64Operand& operand) +asmError x64Parser::Opcode268(x64Operand &operand) { - operand.values[36] = OpcodeCodings268_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings268_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings269_18[] = { - {CODING_NAME("lidt")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lidt") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings269_19[] = { - {CODING_NAME("lidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode269(x64Operand& operand) +asmError x64Parser::Opcode269(x64Operand &operand) { - operand.values[18] = OpcodeCodings269_18; - operand.values[19] = OpcodeCodings269_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings269_18; + operand.values[19] = OpcodeCodings269_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings270_18[] = { - {CODING_NAME("lldt")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lldt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings270_19[] = { - {CODING_NAME("lldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode270(x64Operand& operand) +asmError x64Parser::Opcode270(x64Operand &operand) { - operand.values[18] = OpcodeCodings270_18; - operand.values[19] = OpcodeCodings270_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings270_18; + operand.values[19] = OpcodeCodings270_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings271_18[] = { - {CODING_NAME("lmsw")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lmsw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings271_19[] = { - {CODING_NAME("lmsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lmsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode271(x64Operand& operand) +asmError x64Parser::Opcode271(x64Operand &operand) { - operand.values[18] = OpcodeCodings271_18; - operand.values[19] = OpcodeCodings271_19; - asmError rv = ParseOperands(tokenBranches6829, operand); - return rv; + operand.values[18] = OpcodeCodings271_18; + operand.values[19] = OpcodeCodings271_19; + asmError rv = ParseOperands(tokenBranches6829, operand); + return rv; } -asmError x64Parser::Opcode272(x64Operand& operand) +asmError x64Parser::Opcode272(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6831, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6831, operand); + return rv; } Coding x64Parser::OpcodeCodings273_19[] = { - {CODING_NAME("lodsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode273(x64Operand& operand) +asmError x64Parser::Opcode273(x64Operand &operand) { - operand.values[19] = OpcodeCodings273_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings273_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings274_19[] = { - {CODING_NAME("lodsw") Coding::stateFunc, 4}, - {CODING_NAME("lodsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsw") Coding::stateFunc, 4 }, + { CODING_NAME("lodsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode274(x64Operand& operand) +asmError x64Parser::Opcode274(x64Operand &operand) { - operand.values[19] = OpcodeCodings274_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings274_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings275_19[] = { - {CODING_NAME("lodsd") Coding::stateFunc, 5}, - {CODING_NAME("lodsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsd") Coding::stateFunc, 5 }, + { CODING_NAME("lodsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode275(x64Operand& operand) +asmError x64Parser::Opcode275(x64Operand &operand) { - operand.values[19] = OpcodeCodings275_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings275_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode276(x64Operand& operand) +asmError x64Parser::Opcode276(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6959, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6959, operand); + return rv; } -asmError x64Parser::Opcode277(x64Operand& operand) +asmError x64Parser::Opcode277(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6961, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6961, operand); + return rv; } -asmError x64Parser::Opcode278(x64Operand& operand) +asmError x64Parser::Opcode278(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6963, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6963, operand); + return rv; } -asmError x64Parser::Opcode279(x64Operand& operand) +asmError x64Parser::Opcode279(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6965, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6965, operand); + return rv; } -asmError x64Parser::Opcode280(x64Operand& operand) +asmError x64Parser::Opcode280(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6967, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6967, operand); + return rv; } -asmError x64Parser::Opcode281(x64Operand& operand) +asmError x64Parser::Opcode281(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6969, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6969, operand); + return rv; } Coding x64Parser::OpcodeCodings282_36[] = { - {CODING_NAME("lsl")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lsl")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode282(x64Operand& operand) +asmError x64Parser::Opcode282(x64Operand &operand) { - operand.values[36] = OpcodeCodings282_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings282_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings283_36[] = { - {CODING_NAME("lss") Coding::stateFunc, 7}, - {CODING_NAME("lss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lss") Coding::stateFunc, 7 }, + { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode283(x64Operand& operand) +asmError x64Parser::Opcode283(x64Operand &operand) { - operand.values[36] = OpcodeCodings283_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings283_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings284_18[] = { - {CODING_NAME("ltr")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ltr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings284_19[] = { - {CODING_NAME("ltr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ltr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode284(x64Operand& operand) +asmError x64Parser::Opcode284(x64Operand &operand) { - operand.values[18] = OpcodeCodings284_18; - operand.values[19] = OpcodeCodings284_19; - asmError rv = ParseOperands(tokenBranches6973, operand); - if (rv == AERR_NONE) - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings284_18; + operand.values[19] = OpcodeCodings284_19; + asmError rv = ParseOperands(tokenBranches6973, operand); + if (rv == AERR_NONE) + { + rv = Opcode18(operand); + } + return rv; } -asmError x64Parser::Opcode285(x64Operand& operand) +asmError x64Parser::Opcode285(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6975, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6975, operand); + return rv; } -asmError x64Parser::Opcode286(x64Operand& operand) +asmError x64Parser::Opcode286(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7284, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7284, operand); + return rv; } Coding x64Parser::OpcodeCodings287_36[] = { - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0}, - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode287(x64Operand& operand) +asmError x64Parser::Opcode287(x64Operand &operand) { - operand.values[36] = OpcodeCodings287_36; - asmError rv = ParseOperands(tokenBranches7547, operand); - return rv; + operand.values[36] = OpcodeCodings287_36; + asmError rv = ParseOperands(tokenBranches7547, operand); + return rv; } Coding x64Parser::OpcodeCodings288_19[] = { - {CODING_NAME("movsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode288(x64Operand& operand) +asmError x64Parser::Opcode288(x64Operand &operand) { - operand.values[19] = OpcodeCodings288_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings288_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings289_19[] = { - {CODING_NAME("movsw") Coding::stateFunc, 4}, - {CODING_NAME("movsw")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsw") Coding::stateFunc, 4 }, + { CODING_NAME("movsw") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode289(x64Operand& operand) +asmError x64Parser::Opcode289(x64Operand &operand) { - operand.values[19] = OpcodeCodings289_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings289_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode290(x64Operand& operand) +asmError x64Parser::Opcode290(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7574, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7574, operand); + return rv; } -asmError x64Parser::Opcode291(x64Operand& operand) +asmError x64Parser::Opcode291(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7582, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7582, operand); + return rv; } Coding x64Parser::OpcodeCodings292_36[] = { - {CODING_NAME("movsx")(Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsx") (Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode292(x64Operand& operand) +asmError x64Parser::Opcode292(x64Operand &operand) { - operand.values[36] = OpcodeCodings292_36; - asmError rv; - { - rv = Opcode15(operand); - } - return rv; + operand.values[36] = OpcodeCodings292_36; + asmError rv; + { + rv = Opcode15(operand); + } + return rv; } Coding x64Parser::OpcodeCodings293_36[] = { - {CODING_NAME("movzx")(Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movzx") (Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode293(x64Operand& operand) +asmError x64Parser::Opcode293(x64Operand &operand) { - operand.values[36] = OpcodeCodings293_36; - asmError rv; - { - rv = Opcode15(operand); - } - return rv; + operand.values[36] = OpcodeCodings293_36; + asmError rv; + { + rv = Opcode15(operand); + } + return rv; } -asmError x64Parser::Opcode294(x64Operand& operand) +asmError x64Parser::Opcode294(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7586, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7586, operand); + return rv; } Coding x64Parser::OpcodeCodings295_18[] = { - {CODING_NAME("mul")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mul") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode295(x64Operand& operand) +asmError x64Parser::Opcode295(x64Operand &operand) { - operand.values[18] = OpcodeCodings295_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings295_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings296_18[] = { - {CODING_NAME("neg")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("neg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode296(x64Operand& operand) +asmError x64Parser::Opcode296(x64Operand &operand) { - operand.values[18] = OpcodeCodings296_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings296_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings297_19[] = { - {CODING_NAME("nop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("nop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode297(x64Operand& operand) +asmError x64Parser::Opcode297(x64Operand &operand) { - operand.values[19] = OpcodeCodings297_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings297_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings298_18[] = { - {CODING_NAME("not")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("not") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode298(x64Operand& operand) +asmError x64Parser::Opcode298(x64Operand &operand) { - operand.values[18] = OpcodeCodings298_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings298_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings299_18[] = { - {CODING_NAME("or")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings299_36[] = { - {CODING_NAME("or")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings299_37[] = { - {CODING_NAME("or")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode299(x64Operand& operand) +asmError x64Parser::Opcode299(x64Operand &operand) { - operand.values[18] = OpcodeCodings299_18; - operand.values[36] = OpcodeCodings299_36; - operand.values[37] = OpcodeCodings299_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings299_18; + operand.values[36] = OpcodeCodings299_36; + operand.values[37] = OpcodeCodings299_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode300(x64Operand& operand) +asmError x64Parser::Opcode300(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7606, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7606, operand); + return rv; } -asmError x64Parser::Opcode301(x64Operand& operand) +asmError x64Parser::Opcode301(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7635, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7635, operand); + return rv; } Coding x64Parser::OpcodeCodings302_19[] = { - {CODING_NAME("outsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode302(x64Operand& operand) +asmError x64Parser::Opcode302(x64Operand &operand) { - operand.values[19] = OpcodeCodings302_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings302_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings303_19[] = { - {CODING_NAME("outsw") Coding::stateFunc, 4}, - {CODING_NAME("outsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsw") Coding::stateFunc, 4 }, + { CODING_NAME("outsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode303(x64Operand& operand) +asmError x64Parser::Opcode303(x64Operand &operand) { - operand.values[19] = OpcodeCodings303_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings303_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings304_19[] = { - {CODING_NAME("outsd") Coding::stateFunc, 5}, - {CODING_NAME("outsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsd") Coding::stateFunc, 5 }, + { CODING_NAME("outsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode304(x64Operand& operand) +asmError x64Parser::Opcode304(x64Operand &operand) { - operand.values[19] = OpcodeCodings304_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings304_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode305(x64Operand& operand) +asmError x64Parser::Opcode305(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7777, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7777, operand); + return rv; } Coding x64Parser::OpcodeCodings306_19[] = { - {CODING_NAME("popa") Coding::stateFunc, 7}, - {CODING_NAME("popa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popa") Coding::stateFunc, 7 }, + { CODING_NAME("popa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode306(x64Operand& operand) +asmError x64Parser::Opcode306(x64Operand &operand) { - operand.values[19] = OpcodeCodings306_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings306_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings307_19[] = { - {CODING_NAME("popaw") Coding::stateFunc, 7}, - {CODING_NAME("popaw") Coding::stateFunc, 4}, - {CODING_NAME("popaw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popaw") Coding::stateFunc, 7 }, + { CODING_NAME("popaw") Coding::stateFunc, 4 }, + { CODING_NAME("popaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode307(x64Operand& operand) +asmError x64Parser::Opcode307(x64Operand &operand) { - operand.values[19] = OpcodeCodings307_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings307_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings308_19[] = { - {CODING_NAME("popad") Coding::stateFunc, 7}, - {CODING_NAME("popad") Coding::stateFunc, 5}, - {CODING_NAME("popad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popad") Coding::stateFunc, 7 }, + { CODING_NAME("popad") Coding::stateFunc, 5 }, + { CODING_NAME("popad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode308(x64Operand& operand) +asmError x64Parser::Opcode308(x64Operand &operand) { - operand.values[19] = OpcodeCodings308_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings308_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings309_23[] = { - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings309_36[] = { - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode309(x64Operand& operand) +asmError x64Parser::Opcode309(x64Operand &operand) { - operand.values[23] = OpcodeCodings309_23; - operand.values[36] = OpcodeCodings309_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[23] = OpcodeCodings309_23; + operand.values[36] = OpcodeCodings309_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings310_19[] = { - {CODING_NAME("popf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode310(x64Operand& operand) +asmError x64Parser::Opcode310(x64Operand &operand) { - operand.values[19] = OpcodeCodings310_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings310_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings311_19[] = { - {CODING_NAME("popfw") Coding::stateFunc, 4}, - {CODING_NAME("popfw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfw") Coding::stateFunc, 4 }, + { CODING_NAME("popfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode311(x64Operand& operand) +asmError x64Parser::Opcode311(x64Operand &operand) { - operand.values[19] = OpcodeCodings311_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings311_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings312_19[] = { - {CODING_NAME("popfd") Coding::stateFunc, 5}, - {CODING_NAME("popfd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfd") Coding::stateFunc, 5 }, + { CODING_NAME("popfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode312(x64Operand& operand) +asmError x64Parser::Opcode312(x64Operand &operand) { - operand.values[19] = OpcodeCodings312_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings312_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings313_19[] = { - {CODING_NAME("popfq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode313(x64Operand& operand) +asmError x64Parser::Opcode313(x64Operand &operand) { - operand.values[19] = OpcodeCodings313_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings313_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode314(x64Operand& operand) +asmError x64Parser::Opcode314(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7798, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7798, operand); + return rv; } -asmError x64Parser::Opcode315(x64Operand& operand) +asmError x64Parser::Opcode315(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7800, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7800, operand); + return rv; } -asmError x64Parser::Opcode316(x64Operand& operand) +asmError x64Parser::Opcode316(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7802, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7802, operand); + return rv; } -asmError x64Parser::Opcode317(x64Operand& operand) +asmError x64Parser::Opcode317(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7804, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7804, operand); + return rv; } -asmError x64Parser::Opcode318(x64Operand& operand) +asmError x64Parser::Opcode318(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7806, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7806, operand); + return rv; } Coding x64Parser::OpcodeCodings319_19[] = { - {CODING_NAME("pusha") Coding::stateFunc, 7}, - {CODING_NAME("pusha")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pusha") Coding::stateFunc, 7 }, + { CODING_NAME("pusha") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode319(x64Operand& operand) +asmError x64Parser::Opcode319(x64Operand &operand) { - operand.values[19] = OpcodeCodings319_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings319_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings320_19[] = { - {CODING_NAME("pushaw") Coding::stateFunc, 7}, - {CODING_NAME("pushaw") Coding::stateFunc, 4}, - {CODING_NAME("pushaw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushaw") Coding::stateFunc, 7 }, + { CODING_NAME("pushaw") Coding::stateFunc, 4 }, + { CODING_NAME("pushaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode320(x64Operand& operand) +asmError x64Parser::Opcode320(x64Operand &operand) { - operand.values[19] = OpcodeCodings320_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings320_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings321_19[] = { - {CODING_NAME("pushad") Coding::stateFunc, 7}, - {CODING_NAME("pushad") Coding::stateFunc, 5}, - {CODING_NAME("pushad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushad") Coding::stateFunc, 7 }, + { CODING_NAME("pushad") Coding::stateFunc, 5 }, + { CODING_NAME("pushad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode321(x64Operand& operand) +asmError x64Parser::Opcode321(x64Operand &operand) { - operand.values[19] = OpcodeCodings321_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings321_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings322_19[] = { - {CODING_NAME("pushf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode322(x64Operand& operand) +asmError x64Parser::Opcode322(x64Operand &operand) { - operand.values[19] = OpcodeCodings322_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings322_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings323_19[] = { - {CODING_NAME("pushfw") Coding::stateFunc, 4}, - {CODING_NAME("pushfw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfw") Coding::stateFunc, 4 }, + { CODING_NAME("pushfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode323(x64Operand& operand) +asmError x64Parser::Opcode323(x64Operand &operand) { - operand.values[19] = OpcodeCodings323_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings323_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings324_19[] = { - {CODING_NAME("pushfd") Coding::stateFunc, 5}, - {CODING_NAME("pushfd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfd") Coding::stateFunc, 5 }, + { CODING_NAME("pushfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode324(x64Operand& operand) +asmError x64Parser::Opcode324(x64Operand &operand) { - operand.values[19] = OpcodeCodings324_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings324_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings325_19[] = { - {CODING_NAME("pushfq")(Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfq") (Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode325(x64Operand& operand) +asmError x64Parser::Opcode325(x64Operand &operand) { - operand.values[19] = OpcodeCodings325_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings325_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings326_18[] = { - {CODING_NAME("rcl")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcl") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode326(x64Operand& operand) +asmError x64Parser::Opcode326(x64Operand &operand) { - operand.values[18] = OpcodeCodings326_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings326_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings327_18[] = { - {CODING_NAME("rcr")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode327(x64Operand& operand) +asmError x64Parser::Opcode327(x64Operand &operand) { - operand.values[18] = OpcodeCodings327_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings327_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings328_19[] = { - {CODING_NAME("rdmsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode328(x64Operand& operand) +asmError x64Parser::Opcode328(x64Operand &operand) { - operand.values[19] = OpcodeCodings328_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings328_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings329_19[] = { - {CODING_NAME("rdpmc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdpmc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode329(x64Operand& operand) +asmError x64Parser::Opcode329(x64Operand &operand) { - operand.values[19] = OpcodeCodings329_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings329_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings330_19[] = { - {CODING_NAME("rdtsc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdtsc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode330(x64Operand& operand) +asmError x64Parser::Opcode330(x64Operand &operand) { - operand.values[19] = OpcodeCodings330_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings330_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode331(x64Operand& operand) +asmError x64Parser::Opcode331(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7842, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7842, operand); + return rv; } -asmError x64Parser::Opcode332(x64Operand& operand) +asmError x64Parser::Opcode332(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7845, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7845, operand); + return rv; } Coding x64Parser::OpcodeCodings333_18[] = { - {CODING_NAME("rol")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rol") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode333(x64Operand& operand) +asmError x64Parser::Opcode333(x64Operand &operand) { - operand.values[18] = OpcodeCodings333_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings333_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings334_18[] = { - {CODING_NAME("ror")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ror") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode334(x64Operand& operand) +asmError x64Parser::Opcode334(x64Operand &operand) { - operand.values[18] = OpcodeCodings334_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings334_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings335_19[] = { - {CODING_NAME("rsm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode335(x64Operand& operand) +asmError x64Parser::Opcode335(x64Operand &operand) { - operand.values[19] = OpcodeCodings335_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings335_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings336_19[] = { - {CODING_NAME("sahf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode336(x64Operand& operand) +asmError x64Parser::Opcode336(x64Operand &operand) { - operand.values[19] = OpcodeCodings336_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings336_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings337_18[] = { - {CODING_NAME("sal")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sal") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode337(x64Operand& operand) +asmError x64Parser::Opcode337(x64Operand &operand) { - operand.values[18] = OpcodeCodings337_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings337_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings338_18[] = { - {CODING_NAME("sar")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sar") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode338(x64Operand& operand) +asmError x64Parser::Opcode338(x64Operand &operand) { - operand.values[18] = OpcodeCodings338_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings338_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings339_18[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings339_36[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings339_37[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode339(x64Operand& operand) +asmError x64Parser::Opcode339(x64Operand &operand) { - operand.values[18] = OpcodeCodings339_18; - operand.values[36] = OpcodeCodings339_36; - operand.values[37] = OpcodeCodings339_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings339_18; + operand.values[36] = OpcodeCodings339_36; + operand.values[37] = OpcodeCodings339_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode340(x64Operand& operand) +asmError x64Parser::Opcode340(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7855, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7855, operand); + return rv; } Coding x64Parser::OpcodeCodings341_19[] = { - {CODING_NAME("scasb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode341(x64Operand& operand) +asmError x64Parser::Opcode341(x64Operand &operand) { - operand.values[19] = OpcodeCodings341_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings341_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings342_19[] = { - {CODING_NAME("scasw") Coding::stateFunc, 4}, - {CODING_NAME("scasw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasw") Coding::stateFunc, 4 }, + { CODING_NAME("scasw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode342(x64Operand& operand) +asmError x64Parser::Opcode342(x64Operand &operand) { - operand.values[19] = OpcodeCodings342_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings342_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings343_19[] = { - {CODING_NAME("scasd") Coding::stateFunc, 5}, - {CODING_NAME("scasd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasd") Coding::stateFunc, 5 }, + { CODING_NAME("scasd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode343(x64Operand& operand) +asmError x64Parser::Opcode343(x64Operand &operand) { - operand.values[19] = OpcodeCodings343_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings343_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode344(x64Operand& operand) +asmError x64Parser::Opcode344(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7983, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7983, operand); + return rv; } Coding x64Parser::OpcodeCodings345_38[] = { - {CODING_NAME("seta")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode345(x64Operand& operand) +asmError x64Parser::Opcode345(x64Operand &operand) { - operand.values[38] = OpcodeCodings345_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings345_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings346_38[] = { - {CODING_NAME("setae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode346(x64Operand& operand) +asmError x64Parser::Opcode346(x64Operand &operand) { - operand.values[38] = OpcodeCodings346_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings346_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings347_38[] = { - {CODING_NAME("setb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode347(x64Operand& operand) +asmError x64Parser::Opcode347(x64Operand &operand) { - operand.values[38] = OpcodeCodings347_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings347_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings348_38[] = { - {CODING_NAME("setbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode348(x64Operand& operand) +asmError x64Parser::Opcode348(x64Operand &operand) { - operand.values[38] = OpcodeCodings348_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings348_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings349_38[] = { - {CODING_NAME("setc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode349(x64Operand& operand) +asmError x64Parser::Opcode349(x64Operand &operand) { - operand.values[38] = OpcodeCodings349_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings349_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings350_38[] = { - {CODING_NAME("sete")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode350(x64Operand& operand) +asmError x64Parser::Opcode350(x64Operand &operand) { - operand.values[38] = OpcodeCodings350_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings350_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings351_38[] = { - {CODING_NAME("setg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode351(x64Operand& operand) +asmError x64Parser::Opcode351(x64Operand &operand) { - operand.values[38] = OpcodeCodings351_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings351_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings352_38[] = { - {CODING_NAME("setge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode352(x64Operand& operand) +asmError x64Parser::Opcode352(x64Operand &operand) { - operand.values[38] = OpcodeCodings352_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings352_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings353_38[] = { - {CODING_NAME("setl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode353(x64Operand& operand) +asmError x64Parser::Opcode353(x64Operand &operand) { - operand.values[38] = OpcodeCodings353_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings353_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings354_38[] = { - {CODING_NAME("setle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode354(x64Operand& operand) +asmError x64Parser::Opcode354(x64Operand &operand) { - operand.values[38] = OpcodeCodings354_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings354_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings355_38[] = { - {CODING_NAME("setna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode355(x64Operand& operand) +asmError x64Parser::Opcode355(x64Operand &operand) { - operand.values[38] = OpcodeCodings355_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings355_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings356_38[] = { - {CODING_NAME("setnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode356(x64Operand& operand) +asmError x64Parser::Opcode356(x64Operand &operand) { - operand.values[38] = OpcodeCodings356_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings356_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings357_38[] = { - {CODING_NAME("setnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode357(x64Operand& operand) +asmError x64Parser::Opcode357(x64Operand &operand) { - operand.values[38] = OpcodeCodings357_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings357_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings358_38[] = { - {CODING_NAME("setnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode358(x64Operand& operand) +asmError x64Parser::Opcode358(x64Operand &operand) { - operand.values[38] = OpcodeCodings358_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings358_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings359_38[] = { - {CODING_NAME("setnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode359(x64Operand& operand) +asmError x64Parser::Opcode359(x64Operand &operand) { - operand.values[38] = OpcodeCodings359_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings359_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings360_38[] = { - {CODING_NAME("setne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode360(x64Operand& operand) +asmError x64Parser::Opcode360(x64Operand &operand) { - operand.values[38] = OpcodeCodings360_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings360_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings361_38[] = { - {CODING_NAME("setng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode361(x64Operand& operand) +asmError x64Parser::Opcode361(x64Operand &operand) { - operand.values[38] = OpcodeCodings361_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings361_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings362_38[] = { - {CODING_NAME("setnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode362(x64Operand& operand) +asmError x64Parser::Opcode362(x64Operand &operand) { - operand.values[38] = OpcodeCodings362_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings362_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings363_38[] = { - {CODING_NAME("setnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode363(x64Operand& operand) +asmError x64Parser::Opcode363(x64Operand &operand) { - operand.values[38] = OpcodeCodings363_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings363_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings364_38[] = { - {CODING_NAME("setnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode364(x64Operand& operand) +asmError x64Parser::Opcode364(x64Operand &operand) { - operand.values[38] = OpcodeCodings364_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings364_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings365_38[] = { - {CODING_NAME("setno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode365(x64Operand& operand) +asmError x64Parser::Opcode365(x64Operand &operand) { - operand.values[38] = OpcodeCodings365_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings365_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings366_38[] = { - {CODING_NAME("setnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode366(x64Operand& operand) +asmError x64Parser::Opcode366(x64Operand &operand) { - operand.values[38] = OpcodeCodings366_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings366_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings367_38[] = { - {CODING_NAME("setns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode367(x64Operand& operand) +asmError x64Parser::Opcode367(x64Operand &operand) { - operand.values[38] = OpcodeCodings367_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings367_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings368_38[] = { - {CODING_NAME("setnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode368(x64Operand& operand) +asmError x64Parser::Opcode368(x64Operand &operand) { - operand.values[38] = OpcodeCodings368_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings368_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings369_38[] = { - {CODING_NAME("seto")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode369(x64Operand& operand) +asmError x64Parser::Opcode369(x64Operand &operand) { - operand.values[38] = OpcodeCodings369_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings369_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings370_38[] = { - {CODING_NAME("setp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode370(x64Operand& operand) +asmError x64Parser::Opcode370(x64Operand &operand) { - operand.values[38] = OpcodeCodings370_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings370_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings371_38[] = { - {CODING_NAME("setpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode371(x64Operand& operand) +asmError x64Parser::Opcode371(x64Operand &operand) { - operand.values[38] = OpcodeCodings371_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings371_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings372_38[] = { - {CODING_NAME("setpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode372(x64Operand& operand) +asmError x64Parser::Opcode372(x64Operand &operand) { - operand.values[38] = OpcodeCodings372_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings372_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings373_38[] = { - {CODING_NAME("sets")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode373(x64Operand& operand) +asmError x64Parser::Opcode373(x64Operand &operand) { - operand.values[38] = OpcodeCodings373_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings373_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings374_38[] = { - {CODING_NAME("setz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode374(x64Operand& operand) +asmError x64Parser::Opcode374(x64Operand &operand) { - operand.values[38] = OpcodeCodings374_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings374_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings375_19[] = { - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode375(x64Operand& operand) +asmError x64Parser::Opcode375(x64Operand &operand) { - operand.values[19] = OpcodeCodings375_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings375_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings376_18[] = { - {CODING_NAME("sgdt")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sgdt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings376_19[] = { - {CODING_NAME("sgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode376(x64Operand& operand) +asmError x64Parser::Opcode376(x64Operand &operand) { - operand.values[18] = OpcodeCodings376_18; - operand.values[19] = OpcodeCodings376_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings376_18; + operand.values[19] = OpcodeCodings376_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings377_18[] = { - {CODING_NAME("shl")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shl") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode377(x64Operand& operand) +asmError x64Parser::Opcode377(x64Operand &operand) { - operand.values[18] = OpcodeCodings377_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings377_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings378_36[] = { - {CODING_NAME("shld")(Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shld") (Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode378(x64Operand& operand) +asmError x64Parser::Opcode378(x64Operand &operand) { - operand.values[36] = OpcodeCodings378_36; - asmError rv; - { - rv = Opcode17(operand); - } - return rv; + operand.values[36] = OpcodeCodings378_36; + asmError rv; + { + rv = Opcode17(operand); + } + return rv; } Coding x64Parser::OpcodeCodings379_18[] = { - {CODING_NAME("shr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode379(x64Operand& operand) +asmError x64Parser::Opcode379(x64Operand &operand) { - operand.values[18] = OpcodeCodings379_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings379_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings380_36[] = { - {CODING_NAME("shrd")(Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shrd") (Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode380(x64Operand& operand) +asmError x64Parser::Opcode380(x64Operand &operand) { - operand.values[36] = OpcodeCodings380_36; - asmError rv; - { - rv = Opcode17(operand); - } - return rv; + operand.values[36] = OpcodeCodings380_36; + asmError rv; + { + rv = Opcode17(operand); + } + return rv; } Coding x64Parser::OpcodeCodings381_18[] = { - {CODING_NAME("sidt")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sidt") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings381_19[] = { - {CODING_NAME("sidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode381(x64Operand& operand) +asmError x64Parser::Opcode381(x64Operand &operand) { - operand.values[18] = OpcodeCodings381_18; - operand.values[19] = OpcodeCodings381_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings381_18; + operand.values[19] = OpcodeCodings381_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings382_18[] = { - {CODING_NAME("sldt")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sldt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings382_19[] = { - {CODING_NAME("sldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode382(x64Operand& operand) +asmError x64Parser::Opcode382(x64Operand &operand) { - operand.values[18] = OpcodeCodings382_18; - operand.values[19] = OpcodeCodings382_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings382_18; + operand.values[19] = OpcodeCodings382_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings383_18[] = { - {CODING_NAME("smsw")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("smsw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings383_19[] = { - {CODING_NAME("smsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("smsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode383(x64Operand& operand) +asmError x64Parser::Opcode383(x64Operand &operand) { - operand.values[18] = OpcodeCodings383_18; - operand.values[19] = OpcodeCodings383_19; - asmError rv = ParseOperands(tokenBranches8023, operand); - return rv; + operand.values[18] = OpcodeCodings383_18; + operand.values[19] = OpcodeCodings383_19; + asmError rv = ParseOperands(tokenBranches8023, operand); + return rv; } Coding x64Parser::OpcodeCodings384_19[] = { - {CODING_NAME("stc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode384(x64Operand& operand) +asmError x64Parser::Opcode384(x64Operand &operand) { - operand.values[19] = OpcodeCodings384_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings384_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings385_19[] = { - {CODING_NAME("std")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("std") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode385(x64Operand& operand) +asmError x64Parser::Opcode385(x64Operand &operand) { - operand.values[19] = OpcodeCodings385_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings385_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings386_19[] = { - {CODING_NAME("sti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode386(x64Operand& operand) +asmError x64Parser::Opcode386(x64Operand &operand) { - operand.values[19] = OpcodeCodings386_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings386_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode387(x64Operand& operand) +asmError x64Parser::Opcode387(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8028, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8028, operand); + return rv; } Coding x64Parser::OpcodeCodings388_19[] = { - {CODING_NAME("stosb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode388(x64Operand& operand) +asmError x64Parser::Opcode388(x64Operand &operand) { - operand.values[19] = OpcodeCodings388_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings388_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings389_19[] = { - {CODING_NAME("stosw") Coding::stateFunc, 4}, - {CODING_NAME("stosw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosw") Coding::stateFunc, 4 }, + { CODING_NAME("stosw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode389(x64Operand& operand) +asmError x64Parser::Opcode389(x64Operand &operand) { - operand.values[19] = OpcodeCodings389_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings389_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings390_19[] = { - {CODING_NAME("stosd") Coding::stateFunc, 5}, - {CODING_NAME("stosd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosd") Coding::stateFunc, 5 }, + { CODING_NAME("stosd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode390(x64Operand& operand) +asmError x64Parser::Opcode390(x64Operand &operand) { - operand.values[19] = OpcodeCodings390_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings390_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode391(x64Operand& operand) +asmError x64Parser::Opcode391(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8156, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8156, operand); + return rv; } Coding x64Parser::OpcodeCodings392_18[] = { - {CODING_NAME("str")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("str") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings392_19[] = { - {CODING_NAME("str")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("str")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode392(x64Operand& operand) +asmError x64Parser::Opcode392(x64Operand &operand) { - operand.values[18] = OpcodeCodings392_18; - operand.values[19] = OpcodeCodings392_19; - asmError rv = ParseOperands(tokenBranches8158, operand); - return rv; + operand.values[18] = OpcodeCodings392_18; + operand.values[19] = OpcodeCodings392_19; + asmError rv = ParseOperands(tokenBranches8158, operand); + return rv; } Coding x64Parser::OpcodeCodings393_18[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings393_36[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings393_37[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode393(x64Operand& operand) +asmError x64Parser::Opcode393(x64Operand &operand) { - operand.values[18] = OpcodeCodings393_18; - operand.values[36] = OpcodeCodings393_36; - operand.values[37] = OpcodeCodings393_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings393_18; + operand.values[36] = OpcodeCodings393_36; + operand.values[37] = OpcodeCodings393_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings394_19[] = { - {CODING_NAME("syscall")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("syscall") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode394(x64Operand& operand) +asmError x64Parser::Opcode394(x64Operand &operand) { - operand.values[19] = OpcodeCodings394_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings394_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings395_19[] = { - {CODING_NAME("sysenter")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysenter") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode395(x64Operand& operand) +asmError x64Parser::Opcode395(x64Operand &operand) { - operand.values[19] = OpcodeCodings395_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings395_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings396_19[] = { - {CODING_NAME("sysexit")(Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysexit") (Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode396(x64Operand& operand) +asmError x64Parser::Opcode396(x64Operand &operand) { - operand.values[19] = OpcodeCodings396_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings396_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings397_19[] = { - {CODING_NAME("sysret")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysret") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode397(x64Operand& operand) +asmError x64Parser::Opcode397(x64Operand &operand) { - operand.values[19] = OpcodeCodings397_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings397_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode398(x64Operand& operand) +asmError x64Parser::Opcode398(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8167, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8167, operand); + return rv; } Coding x64Parser::OpcodeCodings399_19[] = { - {CODING_NAME("ud2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ud2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode399(x64Operand& operand) +asmError x64Parser::Opcode399(x64Operand &operand) { - operand.values[19] = OpcodeCodings399_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings399_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings400_18[] = { - {CODING_NAME("verr")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings400_19[] = { - {CODING_NAME("verr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("verr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode400(x64Operand& operand) +asmError x64Parser::Opcode400(x64Operand &operand) { - operand.values[18] = OpcodeCodings400_18; - operand.values[19] = OpcodeCodings400_19; - asmError rv = ParseOperands(tokenBranches8282, operand); - return rv; + operand.values[18] = OpcodeCodings400_18; + operand.values[19] = OpcodeCodings400_19; + asmError rv = ParseOperands(tokenBranches8282, operand); + return rv; } Coding x64Parser::OpcodeCodings401_18[] = { - {CODING_NAME("verw")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verw") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings401_19[] = { - {CODING_NAME("verw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("verw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode401(x64Operand& operand) +asmError x64Parser::Opcode401(x64Operand &operand) { - operand.values[18] = OpcodeCodings401_18; - operand.values[19] = OpcodeCodings401_19; - asmError rv = ParseOperands(tokenBranches8284, operand); - return rv; + operand.values[18] = OpcodeCodings401_18; + operand.values[19] = OpcodeCodings401_19; + asmError rv = ParseOperands(tokenBranches8284, operand); + return rv; } Coding x64Parser::OpcodeCodings402_19[] = { - {CODING_NAME("wait")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode402(x64Operand& operand) +asmError x64Parser::Opcode402(x64Operand &operand) { - operand.values[19] = OpcodeCodings402_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings402_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings403_19[] = { - {CODING_NAME("wbinvd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wbinvd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode403(x64Operand& operand) +asmError x64Parser::Opcode403(x64Operand &operand) { - operand.values[19] = OpcodeCodings403_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings403_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings404_19[] = { - {CODING_NAME("wrmsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wrmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode404(x64Operand& operand) +asmError x64Parser::Opcode404(x64Operand &operand) { - operand.values[19] = OpcodeCodings404_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings404_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode405(x64Operand& operand) +asmError x64Parser::Opcode405(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8289, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8289, operand); + return rv; } -asmError x64Parser::Opcode406(x64Operand& operand) +asmError x64Parser::Opcode406(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8310, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8310, operand); + return rv; } -asmError x64Parser::Opcode407(x64Operand& operand) +asmError x64Parser::Opcode407(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8369, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8369, operand); + return rv; } Coding x64Parser::OpcodeCodings408_19[] = { - {CODING_NAME("xlatb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xlatb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode408(x64Operand& operand) +asmError x64Parser::Opcode408(x64Operand &operand) { - operand.values[19] = OpcodeCodings408_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings408_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings409_18[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings409_36[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings409_37[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode409(x64Operand& operand) +asmError x64Parser::Opcode409(x64Operand &operand) { - operand.values[18] = OpcodeCodings409_18; - operand.values[36] = OpcodeCodings409_36; - operand.values[37] = OpcodeCodings409_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings409_18; + operand.values[36] = OpcodeCodings409_36; + operand.values[37] = OpcodeCodings409_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode410(x64Operand& operand) +asmError x64Parser::Opcode410(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8409, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8409, operand); + return rv; } -asmError x64Parser::Opcode411(x64Operand& operand) +asmError x64Parser::Opcode411(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8411, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8411, operand); + return rv; } -asmError x64Parser::Opcode412(x64Operand& operand) +asmError x64Parser::Opcode412(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8413, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8413, operand); + return rv; } -asmError x64Parser::Opcode413(x64Operand& operand) +asmError x64Parser::Opcode413(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8415, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8415, operand); + return rv; } Coding x64Parser::OpcodeCodings414_19[] = { - {CODING_NAME("xsetbv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("xsetbv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode414(x64Operand& operand) +asmError x64Parser::Opcode414(x64Operand &operand) { - operand.values[19] = OpcodeCodings414_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings414_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings415_23[] = { - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings415_19[] = { - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode415(x64Operand& operand) +asmError x64Parser::Opcode415(x64Operand &operand) { - operand.values[23] = OpcodeCodings415_23; - operand.values[19] = OpcodeCodings415_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings415_23; + operand.values[19] = OpcodeCodings415_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings416_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings416_19[] = { - {CODING_NAME("addps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode416(x64Operand& operand) +asmError x64Parser::Opcode416(x64Operand &operand) { - operand.values[23] = OpcodeCodings416_23; - operand.values[19] = OpcodeCodings416_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings416_23; + operand.values[19] = OpcodeCodings416_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings417_23[] = { - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings417_19[] = { - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode417(x64Operand& operand) +asmError x64Parser::Opcode417(x64Operand &operand) { - operand.values[23] = OpcodeCodings417_23; - operand.values[19] = OpcodeCodings417_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings417_23; + operand.values[19] = OpcodeCodings417_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings418_23[] = { - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings418_19[] = { - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode418(x64Operand& operand) +asmError x64Parser::Opcode418(x64Operand &operand) { - operand.values[23] = OpcodeCodings418_23; - operand.values[19] = OpcodeCodings418_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings418_23; + operand.values[19] = OpcodeCodings418_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings419_23[] = { - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings419_19[] = { - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode419(x64Operand& operand) +asmError x64Parser::Opcode419(x64Operand &operand) { - operand.values[23] = OpcodeCodings419_23; - operand.values[19] = OpcodeCodings419_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings419_23; + operand.values[19] = OpcodeCodings419_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings420_23[] = { - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings420_19[] = { - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode420(x64Operand& operand) +asmError x64Parser::Opcode420(x64Operand &operand) { - operand.values[23] = OpcodeCodings420_23; - operand.values[19] = OpcodeCodings420_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings420_23; + operand.values[19] = OpcodeCodings420_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings421_23[] = { - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings421_19[] = { - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode421(x64Operand& operand) +asmError x64Parser::Opcode421(x64Operand &operand) { - operand.values[23] = OpcodeCodings421_23; - operand.values[19] = OpcodeCodings421_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings421_23; + operand.values[19] = OpcodeCodings421_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings422_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings422_19[] = { - {CODING_NAME("andnps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andnps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode422(x64Operand& operand) +asmError x64Parser::Opcode422(x64Operand &operand) { - operand.values[23] = OpcodeCodings422_23; - operand.values[19] = OpcodeCodings422_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings422_23; + operand.values[19] = OpcodeCodings422_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings423_23[] = { - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings423_19[] = { - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode423(x64Operand& operand) +asmError x64Parser::Opcode423(x64Operand &operand) { - operand.values[23] = OpcodeCodings423_23; - operand.values[19] = OpcodeCodings423_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings423_23; + operand.values[19] = OpcodeCodings423_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings424_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings424_19[] = { - {CODING_NAME("andps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode424(x64Operand& operand) +asmError x64Parser::Opcode424(x64Operand &operand) { - operand.values[23] = OpcodeCodings424_23; - operand.values[19] = OpcodeCodings424_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings424_23; + operand.values[19] = OpcodeCodings424_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings425_23[] = { - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings425_19[] = { - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode425(x64Operand& operand) +asmError x64Parser::Opcode425(x64Operand &operand) { - operand.values[23] = OpcodeCodings425_23; - operand.values[19] = OpcodeCodings425_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings425_23; + operand.values[19] = OpcodeCodings425_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings426_23[] = { - {CODING_NAME("blendps")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings426_19[] = { - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode426(x64Operand& operand) +asmError x64Parser::Opcode426(x64Operand &operand) { - operand.values[23] = OpcodeCodings426_23; - operand.values[19] = OpcodeCodings426_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings426_23; + operand.values[19] = OpcodeCodings426_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings427_23[] = { - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings427_19[] = { - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode427(x64Operand& operand) +asmError x64Parser::Opcode427(x64Operand &operand) { - operand.values[23] = OpcodeCodings427_23; - operand.values[19] = OpcodeCodings427_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings427_23; + operand.values[19] = OpcodeCodings427_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings428_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings428_19[] = { - {CODING_NAME("cmpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode428(x64Operand& operand) +asmError x64Parser::Opcode428(x64Operand &operand) { - operand.values[23] = OpcodeCodings428_23; - operand.values[19] = OpcodeCodings428_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings428_23; + operand.values[19] = OpcodeCodings428_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings429_23[] = { - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings429_19[] = { - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode429(x64Operand& operand) +asmError x64Parser::Opcode429(x64Operand &operand) { - operand.values[23] = OpcodeCodings429_23; - operand.values[19] = OpcodeCodings429_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings429_23; + operand.values[19] = OpcodeCodings429_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings430_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings430_19[] = { - {CODING_NAME("comiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("comiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode430(x64Operand& operand) +asmError x64Parser::Opcode430(x64Operand &operand) { - operand.values[23] = OpcodeCodings430_23; - operand.values[19] = OpcodeCodings430_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings430_23; + operand.values[19] = OpcodeCodings430_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings431_23[] = { - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings431_19[] = { - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode431(x64Operand& operand) +asmError x64Parser::Opcode431(x64Operand &operand) { - operand.values[23] = OpcodeCodings431_23; - operand.values[19] = OpcodeCodings431_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings431_23; + operand.values[19] = OpcodeCodings431_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings432_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings432_19[] = { - {CODING_NAME("cvtdq2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtdq2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode432(x64Operand& operand) +asmError x64Parser::Opcode432(x64Operand &operand) { - operand.values[23] = OpcodeCodings432_23; - operand.values[19] = OpcodeCodings432_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings432_23; + operand.values[19] = OpcodeCodings432_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings433_23[] = { - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings433_19[] = { - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode433(x64Operand& operand) +asmError x64Parser::Opcode433(x64Operand &operand) { - operand.values[23] = OpcodeCodings433_23; - operand.values[19] = OpcodeCodings433_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings433_23; + operand.values[19] = OpcodeCodings433_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings434_23[] = { - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings434_19[] = { - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode434(x64Operand& operand) +asmError x64Parser::Opcode434(x64Operand &operand) { - operand.values[23] = OpcodeCodings434_23; - operand.values[19] = OpcodeCodings434_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings434_23; + operand.values[19] = OpcodeCodings434_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings435_23[] = { - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings435_19[] = { - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode435(x64Operand& operand) +asmError x64Parser::Opcode435(x64Operand &operand) { - operand.values[23] = OpcodeCodings435_23; - operand.values[19] = OpcodeCodings435_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings435_23; + operand.values[19] = OpcodeCodings435_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings436_23[] = { - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings436_19[] = { - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode436(x64Operand& operand) +asmError x64Parser::Opcode436(x64Operand &operand) { - operand.values[23] = OpcodeCodings436_23; - operand.values[19] = OpcodeCodings436_19; - asmError rv; - { - rv = Opcode24(operand); - } - return rv; + operand.values[23] = OpcodeCodings436_23; + operand.values[19] = OpcodeCodings436_19; + asmError rv; + { + rv = Opcode24(operand); + } + return rv; } Coding x64Parser::OpcodeCodings437_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings437_19[] = { - {CODING_NAME("cvtpi2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpi2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode437(x64Operand& operand) +asmError x64Parser::Opcode437(x64Operand &operand) { - operand.values[23] = OpcodeCodings437_23; - operand.values[19] = OpcodeCodings437_19; - asmError rv; - { - rv = Opcode24(operand); - } - return rv; + operand.values[23] = OpcodeCodings437_23; + operand.values[19] = OpcodeCodings437_19; + asmError rv; + { + rv = Opcode24(operand); + } + return rv; } Coding x64Parser::OpcodeCodings438_23[] = { - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings438_19[] = { - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode438(x64Operand& operand) +asmError x64Parser::Opcode438(x64Operand &operand) { - operand.values[23] = OpcodeCodings438_23; - operand.values[19] = OpcodeCodings438_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings438_23; + operand.values[19] = OpcodeCodings438_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings439_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings439_19[] = { - {CODING_NAME("cvtps2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode439(x64Operand& operand) +asmError x64Parser::Opcode439(x64Operand &operand) { - operand.values[23] = OpcodeCodings439_23; - operand.values[19] = OpcodeCodings439_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings439_23; + operand.values[19] = OpcodeCodings439_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings440_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings440_19[] = { - {CODING_NAME("cvtps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode440(x64Operand& operand) +asmError x64Parser::Opcode440(x64Operand &operand) { - operand.values[23] = OpcodeCodings440_23; - operand.values[19] = OpcodeCodings440_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings440_23; + operand.values[19] = OpcodeCodings440_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings441_23[] = { - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings441_19[] = { - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode441(x64Operand& operand) +asmError x64Parser::Opcode441(x64Operand &operand) { - operand.values[23] = OpcodeCodings441_23; - operand.values[19] = OpcodeCodings441_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings441_23; + operand.values[19] = OpcodeCodings441_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings442_23[] = { - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings442_19[] = { - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode442(x64Operand& operand) +asmError x64Parser::Opcode442(x64Operand &operand) { - operand.values[23] = OpcodeCodings442_23; - operand.values[19] = OpcodeCodings442_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings442_23; + operand.values[19] = OpcodeCodings442_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings443_23[] = { - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings443_19[] = { - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode443(x64Operand& operand) +asmError x64Parser::Opcode443(x64Operand &operand) { - operand.values[23] = OpcodeCodings443_23; - operand.values[19] = OpcodeCodings443_19; - asmError rv; - { - rv = Opcode26(operand); - } - return rv; + operand.values[23] = OpcodeCodings443_23; + operand.values[19] = OpcodeCodings443_19; + asmError rv; + { + rv = Opcode26(operand); + } + return rv; } Coding x64Parser::OpcodeCodings444_23[] = { - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings444_19[] = { - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode444(x64Operand& operand) +asmError x64Parser::Opcode444(x64Operand &operand) { - operand.values[23] = OpcodeCodings444_23; - operand.values[19] = OpcodeCodings444_19; - asmError rv; - { - rv = Opcode26(operand); - } - return rv; + operand.values[23] = OpcodeCodings444_23; + operand.values[19] = OpcodeCodings444_19; + asmError rv; + { + rv = Opcode26(operand); + } + return rv; } Coding x64Parser::OpcodeCodings445_23[] = { - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings445_19[] = { - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode445(x64Operand& operand) +asmError x64Parser::Opcode445(x64Operand &operand) { - operand.values[23] = OpcodeCodings445_23; - operand.values[19] = OpcodeCodings445_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings445_23; + operand.values[19] = OpcodeCodings445_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings446_23[] = { - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings446_19[] = { - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode446(x64Operand& operand) +asmError x64Parser::Opcode446(x64Operand &operand) { - operand.values[23] = OpcodeCodings446_23; - operand.values[19] = OpcodeCodings446_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings446_23; + operand.values[19] = OpcodeCodings446_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings447_23[] = { - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings447_19[] = { - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode447(x64Operand& operand) +asmError x64Parser::Opcode447(x64Operand &operand) { - operand.values[23] = OpcodeCodings447_23; - operand.values[19] = OpcodeCodings447_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings447_23; + operand.values[19] = OpcodeCodings447_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings448_23[] = { - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings448_19[] = { - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode448(x64Operand& operand) +asmError x64Parser::Opcode448(x64Operand &operand) { - operand.values[23] = OpcodeCodings448_23; - operand.values[19] = OpcodeCodings448_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings448_23; + operand.values[19] = OpcodeCodings448_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings449_23[] = { - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings449_19[] = { - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode449(x64Operand& operand) +asmError x64Parser::Opcode449(x64Operand &operand) { - operand.values[23] = OpcodeCodings449_23; - operand.values[19] = OpcodeCodings449_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings449_23; + operand.values[19] = OpcodeCodings449_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings450_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings450_19[] = { - {CODING_NAME("cvttps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode450(x64Operand& operand) +asmError x64Parser::Opcode450(x64Operand &operand) { - operand.values[23] = OpcodeCodings450_23; - operand.values[19] = OpcodeCodings450_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings450_23; + operand.values[19] = OpcodeCodings450_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings451_23[] = { - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings451_19[] = { - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode451(x64Operand& operand) +asmError x64Parser::Opcode451(x64Operand &operand) { - operand.values[23] = OpcodeCodings451_23; - operand.values[19] = OpcodeCodings451_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings451_23; + operand.values[19] = OpcodeCodings451_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings452_23[] = { - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings452_19[] = { - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode452(x64Operand& operand) +asmError x64Parser::Opcode452(x64Operand &operand) { - operand.values[23] = OpcodeCodings452_23; - operand.values[19] = OpcodeCodings452_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings452_23; + operand.values[19] = OpcodeCodings452_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings453_23[] = { - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings453_19[] = { - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode453(x64Operand& operand) +asmError x64Parser::Opcode453(x64Operand &operand) { - operand.values[23] = OpcodeCodings453_23; - operand.values[19] = OpcodeCodings453_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings453_23; + operand.values[19] = OpcodeCodings453_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings454_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings454_19[] = { - {CODING_NAME("divps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode454(x64Operand& operand) +asmError x64Parser::Opcode454(x64Operand &operand) { - operand.values[23] = OpcodeCodings454_23; - operand.values[19] = OpcodeCodings454_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings454_23; + operand.values[19] = OpcodeCodings454_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings455_23[] = { - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings455_19[] = { - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode455(x64Operand& operand) +asmError x64Parser::Opcode455(x64Operand &operand) { - operand.values[23] = OpcodeCodings455_23; - operand.values[19] = OpcodeCodings455_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings455_23; + operand.values[19] = OpcodeCodings455_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings456_23[] = { - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings456_19[] = { - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode456(x64Operand& operand) +asmError x64Parser::Opcode456(x64Operand &operand) { - operand.values[23] = OpcodeCodings456_23; - operand.values[19] = OpcodeCodings456_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings456_23; + operand.values[19] = OpcodeCodings456_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings457_23[] = { - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings457_19[] = { - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode457(x64Operand& operand) +asmError x64Parser::Opcode457(x64Operand &operand) { - operand.values[23] = OpcodeCodings457_23; - operand.values[19] = OpcodeCodings457_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings457_23; + operand.values[19] = OpcodeCodings457_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings458_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings458_19[] = { - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode458(x64Operand& operand) +asmError x64Parser::Opcode458(x64Operand &operand) { - operand.values[23] = OpcodeCodings458_23; - operand.values[19] = OpcodeCodings458_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings458_23; + operand.values[19] = OpcodeCodings458_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings459_23[] = { - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings459_19[] = { - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode459(x64Operand& operand) +asmError x64Parser::Opcode459(x64Operand &operand) { - operand.values[23] = OpcodeCodings459_23; - operand.values[19] = OpcodeCodings459_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings459_23; + operand.values[19] = OpcodeCodings459_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings460_23[] = { - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings460_19[] = { - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode460(x64Operand& operand) +asmError x64Parser::Opcode460(x64Operand &operand) { - operand.values[23] = OpcodeCodings460_23; - operand.values[19] = OpcodeCodings460_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings460_23; + operand.values[19] = OpcodeCodings460_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings461_23[] = { - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings461_19[] = { - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode461(x64Operand& operand) +asmError x64Parser::Opcode461(x64Operand &operand) { - operand.values[23] = OpcodeCodings461_23; - operand.values[19] = OpcodeCodings461_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings461_23; + operand.values[19] = OpcodeCodings461_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings462_23[] = { - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings462_19[] = { - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode462(x64Operand& operand) +asmError x64Parser::Opcode462(x64Operand &operand) { - operand.values[23] = OpcodeCodings462_23; - operand.values[19] = OpcodeCodings462_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings462_23; + operand.values[19] = OpcodeCodings462_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } -asmError x64Parser::Opcode463(x64Operand& operand) +asmError x64Parser::Opcode463(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8466, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8466, operand); + return rv; } -asmError x64Parser::Opcode464(x64Operand& operand) +asmError x64Parser::Opcode464(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8470, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8470, operand); + return rv; } Coding x64Parser::OpcodeCodings465_23[] = { - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings465_19[] = { - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode465(x64Operand& operand) +asmError x64Parser::Opcode465(x64Operand &operand) { - operand.values[23] = OpcodeCodings465_23; - operand.values[19] = OpcodeCodings465_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings465_23; + operand.values[19] = OpcodeCodings465_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings466_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings466_19[] = { - {CODING_NAME("maxps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode466(x64Operand& operand) +asmError x64Parser::Opcode466(x64Operand &operand) { - operand.values[23] = OpcodeCodings466_23; - operand.values[19] = OpcodeCodings466_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings466_23; + operand.values[19] = OpcodeCodings466_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings467_23[] = { - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings467_19[] = { - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode467(x64Operand& operand) +asmError x64Parser::Opcode467(x64Operand &operand) { - operand.values[23] = OpcodeCodings467_23; - operand.values[19] = OpcodeCodings467_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings467_23; + operand.values[19] = OpcodeCodings467_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings468_23[] = { - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings468_19[] = { - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode468(x64Operand& operand) +asmError x64Parser::Opcode468(x64Operand &operand) { - operand.values[23] = OpcodeCodings468_23; - operand.values[19] = OpcodeCodings468_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings468_23; + operand.values[19] = OpcodeCodings468_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings469_19[] = { - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode469(x64Operand& operand) +asmError x64Parser::Opcode469(x64Operand &operand) { - operand.values[19] = OpcodeCodings469_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings469_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -Coding x64Parser::OpcodeCodings470_23[] = { - {CODING_NAME("eot") Coding::eot}, -}; Coding x64Parser::OpcodeCodings470_19[] = { - {CODING_NAME("pause")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("pause")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode470(x64Operand& operand) +asmError x64Parser::Opcode470(x64Operand &operand) { - operand.values[23] = OpcodeCodings470_23; - operand.values[19] = OpcodeCodings470_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings470_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings471_23[] = { - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings471_19[] = { - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode471(x64Operand& operand) +asmError x64Parser::Opcode471(x64Operand &operand) { - operand.values[23] = OpcodeCodings471_23; - operand.values[19] = OpcodeCodings471_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings471_23; + operand.values[19] = OpcodeCodings471_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings472_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings472_19[] = { - {CODING_NAME("minps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode472(x64Operand& operand) +asmError x64Parser::Opcode472(x64Operand &operand) { - operand.values[23] = OpcodeCodings472_23; - operand.values[19] = OpcodeCodings472_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings472_23; + operand.values[19] = OpcodeCodings472_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings473_23[] = { - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings473_19[] = { - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode473(x64Operand& operand) +asmError x64Parser::Opcode473(x64Operand &operand) { - operand.values[23] = OpcodeCodings473_23; - operand.values[19] = OpcodeCodings473_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings473_23; + operand.values[19] = OpcodeCodings473_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings474_23[] = { - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings474_19[] = { - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode474(x64Operand& operand) +asmError x64Parser::Opcode474(x64Operand &operand) { - operand.values[23] = OpcodeCodings474_23; - operand.values[19] = OpcodeCodings474_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings474_23; + operand.values[19] = OpcodeCodings474_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings475_19[] = { - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode475(x64Operand& operand) +asmError x64Parser::Opcode475(x64Operand &operand) { - operand.values[19] = OpcodeCodings475_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings475_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings476_23[] = { - {CODING_NAME("movapd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movapd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings476_36[] = { - {CODING_NAME("movapd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movapd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode476(x64Operand& operand) +asmError x64Parser::Opcode476(x64Operand &operand) { - operand.values[23] = OpcodeCodings476_23; - operand.values[36] = OpcodeCodings476_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings476_23; + operand.values[36] = OpcodeCodings476_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings477_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings477_36[] = { - {CODING_NAME("movaps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movaps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode477(x64Operand& operand) +asmError x64Parser::Opcode477(x64Operand &operand) { - operand.values[23] = OpcodeCodings477_23; - operand.values[36] = OpcodeCodings477_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings477_23; + operand.values[36] = OpcodeCodings477_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } -asmError x64Parser::Opcode478(x64Operand& operand) +asmError x64Parser::Opcode478(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8487, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8487, operand); + return rv; } -asmError x64Parser::Opcode479(x64Operand& operand) +asmError x64Parser::Opcode479(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8500, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8500, operand); + return rv; } Coding x64Parser::OpcodeCodings480_23[] = { - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings480_19[] = { - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode480(x64Operand& operand) +asmError x64Parser::Opcode480(x64Operand &operand) { - operand.values[23] = OpcodeCodings480_23; - operand.values[19] = OpcodeCodings480_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings480_23; + operand.values[19] = OpcodeCodings480_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings481_23[] = { - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings481_19[] = { - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode481(x64Operand& operand) +asmError x64Parser::Opcode481(x64Operand &operand) { - operand.values[23] = OpcodeCodings481_23; - operand.values[19] = OpcodeCodings481_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings481_23; + operand.values[19] = OpcodeCodings481_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings482_23[] = { - {CODING_NAME("movdqa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings482_36[] = { - {CODING_NAME("movdqa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode482(x64Operand& operand) +asmError x64Parser::Opcode482(x64Operand &operand) { - operand.values[23] = OpcodeCodings482_23; - operand.values[36] = OpcodeCodings482_36; - asmError rv; - { - rv = Opcode21(operand); - } - return rv; + operand.values[23] = OpcodeCodings482_23; + operand.values[36] = OpcodeCodings482_36; + asmError rv; + { + rv = Opcode21(operand); + } + return rv; } Coding x64Parser::OpcodeCodings483_23[] = { - {CODING_NAME("movdqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings483_36[] = { - {CODING_NAME("movdqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode483(x64Operand& operand) +asmError x64Parser::Opcode483(x64Operand &operand) { - operand.values[23] = OpcodeCodings483_23; - operand.values[36] = OpcodeCodings483_36; - asmError rv; - { - rv = Opcode21(operand); - } - return rv; + operand.values[23] = OpcodeCodings483_23; + operand.values[36] = OpcodeCodings483_36; + asmError rv; + { + rv = Opcode21(operand); + } + return rv; } -asmError x64Parser::Opcode484(x64Operand& operand) +asmError x64Parser::Opcode484(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8529, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8529, operand); + return rv; } Coding x64Parser::OpcodeCodings485_23[] = { - {CODING_NAME("movhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings485_36[] = { - {CODING_NAME("movhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode485(x64Operand& operand) +asmError x64Parser::Opcode485(x64Operand &operand) { - operand.values[23] = OpcodeCodings485_23; - operand.values[36] = OpcodeCodings485_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings485_23; + operand.values[36] = OpcodeCodings485_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings486_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings486_36[] = { - {CODING_NAME("movhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode486(x64Operand& operand) +asmError x64Parser::Opcode486(x64Operand &operand) { - operand.values[23] = OpcodeCodings486_23; - operand.values[36] = OpcodeCodings486_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings486_23; + operand.values[36] = OpcodeCodings486_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } -asmError x64Parser::Opcode487(x64Operand& operand) +asmError x64Parser::Opcode487(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8535, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8535, operand); + return rv; } Coding x64Parser::OpcodeCodings488_23[] = { - {CODING_NAME("movlpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings488_36[] = { - {CODING_NAME("movlpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode488(x64Operand& operand) +asmError x64Parser::Opcode488(x64Operand &operand) { - operand.values[23] = OpcodeCodings488_23; - operand.values[36] = OpcodeCodings488_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings488_23; + operand.values[36] = OpcodeCodings488_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings489_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings489_36[] = { - {CODING_NAME("movlps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode489(x64Operand& operand) +asmError x64Parser::Opcode489(x64Operand &operand) { - operand.values[23] = OpcodeCodings489_23; - operand.values[36] = OpcodeCodings489_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings489_23; + operand.values[36] = OpcodeCodings489_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings490_23[] = { - {CODING_NAME("movmskpd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings490_19[] = { - {CODING_NAME("movmskpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movmskpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode490(x64Operand& operand) +asmError x64Parser::Opcode490(x64Operand &operand) { - operand.values[23] = OpcodeCodings490_23; - operand.values[19] = OpcodeCodings490_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings490_23; + operand.values[19] = OpcodeCodings490_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings491_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings491_19[] = { - {CODING_NAME("movmskps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movmskps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode491(x64Operand& operand) +asmError x64Parser::Opcode491(x64Operand &operand) { - operand.values[23] = OpcodeCodings491_23; - operand.values[19] = OpcodeCodings491_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings491_23; + operand.values[19] = OpcodeCodings491_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } -asmError x64Parser::Opcode492(x64Operand& operand) +asmError x64Parser::Opcode492(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8543, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8543, operand); + return rv; } Coding x64Parser::OpcodeCodings493_19[] = { - {CODING_NAME("movnti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movnti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode493(x64Operand& operand) +asmError x64Parser::Opcode493(x64Operand &operand) { - operand.values[19] = OpcodeCodings493_19; - asmError rv = ParseOperands(tokenBranches8547, operand); - return rv; + operand.values[19] = OpcodeCodings493_19; + asmError rv = ParseOperands(tokenBranches8547, operand); + return rv; } -asmError x64Parser::Opcode494(x64Operand& operand) +asmError x64Parser::Opcode494(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8554, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8554, operand); + return rv; } -asmError x64Parser::Opcode495(x64Operand& operand) +asmError x64Parser::Opcode495(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8558, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8558, operand); + return rv; } -asmError x64Parser::Opcode496(x64Operand& operand) +asmError x64Parser::Opcode496(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8562, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8562, operand); + return rv; } -asmError x64Parser::Opcode497(x64Operand& operand) +asmError x64Parser::Opcode497(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8566, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8566, operand); + return rv; } Coding x64Parser::OpcodeCodings498_23[] = { - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings498_19[] = { - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode498(x64Operand& operand) +asmError x64Parser::Opcode498(x64Operand &operand) { - operand.values[23] = OpcodeCodings498_23; - operand.values[19] = OpcodeCodings498_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings498_23; + operand.values[19] = OpcodeCodings498_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings499_23[] = { - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings499_19[] = { - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode499(x64Operand& operand) +asmError x64Parser::Opcode499(x64Operand &operand) { - operand.values[23] = OpcodeCodings499_23; - operand.values[19] = OpcodeCodings499_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings499_23; + operand.values[19] = OpcodeCodings499_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings500_23[] = { - {CODING_NAME("movss")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movss") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings500_36[] = { - {CODING_NAME("movss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode500(x64Operand& operand) +asmError x64Parser::Opcode500(x64Operand &operand) { - operand.values[23] = OpcodeCodings500_23; - operand.values[36] = OpcodeCodings500_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings500_23; + operand.values[36] = OpcodeCodings500_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings501_23[] = { - {CODING_NAME("movupd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movupd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings501_36[] = { - {CODING_NAME("movupd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movupd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode501(x64Operand& operand) +asmError x64Parser::Opcode501(x64Operand &operand) { - operand.values[23] = OpcodeCodings501_23; - operand.values[36] = OpcodeCodings501_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings501_23; + operand.values[36] = OpcodeCodings501_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings502_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings502_36[] = { - {CODING_NAME("movups")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movups") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode502(x64Operand& operand) +asmError x64Parser::Opcode502(x64Operand &operand) { - operand.values[23] = OpcodeCodings502_23; - operand.values[36] = OpcodeCodings502_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings502_23; + operand.values[36] = OpcodeCodings502_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings503_23[] = { - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings503_19[] = { - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode503(x64Operand& operand) +asmError x64Parser::Opcode503(x64Operand &operand) { - operand.values[23] = OpcodeCodings503_23; - operand.values[19] = OpcodeCodings503_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings503_23; + operand.values[19] = OpcodeCodings503_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings504_23[] = { - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings504_19[] = { - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode504(x64Operand& operand) +asmError x64Parser::Opcode504(x64Operand &operand) { - operand.values[23] = OpcodeCodings504_23; - operand.values[19] = OpcodeCodings504_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings504_23; + operand.values[19] = OpcodeCodings504_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings505_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings505_19[] = { - {CODING_NAME("mulps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode505(x64Operand& operand) +asmError x64Parser::Opcode505(x64Operand &operand) { - operand.values[23] = OpcodeCodings505_23; - operand.values[19] = OpcodeCodings505_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings505_23; + operand.values[19] = OpcodeCodings505_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings506_23[] = { - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings506_19[] = { - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode506(x64Operand& operand) +asmError x64Parser::Opcode506(x64Operand &operand) { - operand.values[23] = OpcodeCodings506_23; - operand.values[19] = OpcodeCodings506_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings506_23; + operand.values[19] = OpcodeCodings506_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings507_23[] = { - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings507_19[] = { - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode507(x64Operand& operand) +asmError x64Parser::Opcode507(x64Operand &operand) { - operand.values[23] = OpcodeCodings507_23; - operand.values[19] = OpcodeCodings507_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings507_23; + operand.values[19] = OpcodeCodings507_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings508_23[] = { - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings508_19[] = { - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode508(x64Operand& operand) +asmError x64Parser::Opcode508(x64Operand &operand) { - operand.values[23] = OpcodeCodings508_23; - operand.values[19] = OpcodeCodings508_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings508_23; + operand.values[19] = OpcodeCodings508_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings509_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings509_19[] = { - {CODING_NAME("orps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("orps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode509(x64Operand& operand) +asmError x64Parser::Opcode509(x64Operand &operand) { - operand.values[23] = OpcodeCodings509_23; - operand.values[19] = OpcodeCodings509_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings509_23; + operand.values[19] = OpcodeCodings509_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings510_19[] = { - {CODING_NAME("packssdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packssdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode510(x64Operand& operand) +asmError x64Parser::Opcode510(x64Operand &operand) { - operand.values[19] = OpcodeCodings510_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings510_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings511_19[] = { - {CODING_NAME("packsswb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packsswb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode511(x64Operand& operand) +asmError x64Parser::Opcode511(x64Operand &operand) { - operand.values[19] = OpcodeCodings511_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings511_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings512_23[] = { - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings512_19[] = { - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0}, - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode512(x64Operand& operand) +asmError x64Parser::Opcode512(x64Operand &operand) { - operand.values[23] = OpcodeCodings512_23; - operand.values[19] = OpcodeCodings512_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings512_23; + operand.values[19] = OpcodeCodings512_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings513_19[] = { - {CODING_NAME("paddb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode513(x64Operand& operand) +asmError x64Parser::Opcode513(x64Operand &operand) { - operand.values[19] = OpcodeCodings513_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings513_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings514_19[] = { - {CODING_NAME("paddd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode514(x64Operand& operand) +asmError x64Parser::Opcode514(x64Operand &operand) { - operand.values[19] = OpcodeCodings514_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings514_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings515_19[] = { - {CODING_NAME("paddq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode515(x64Operand& operand) +asmError x64Parser::Opcode515(x64Operand &operand) { - operand.values[19] = OpcodeCodings515_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings515_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings516_19[] = { - {CODING_NAME("paddsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode516(x64Operand& operand) +asmError x64Parser::Opcode516(x64Operand &operand) { - operand.values[19] = OpcodeCodings516_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings516_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings517_19[] = { - {CODING_NAME("paddusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode517(x64Operand& operand) +asmError x64Parser::Opcode517(x64Operand &operand) { - operand.values[19] = OpcodeCodings517_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings517_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings518_19[] = { - {CODING_NAME("paddusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode518(x64Operand& operand) +asmError x64Parser::Opcode518(x64Operand &operand) { - operand.values[19] = OpcodeCodings518_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings518_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings519_19[] = { - {CODING_NAME("paddw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode519(x64Operand& operand) +asmError x64Parser::Opcode519(x64Operand &operand) { - operand.values[19] = OpcodeCodings519_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings519_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings520_19[] = { - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode520(x64Operand& operand) +asmError x64Parser::Opcode520(x64Operand &operand) { - operand.values[19] = OpcodeCodings520_19; - asmError rv = ParseOperands(tokenBranches8592, operand); - return rv; + operand.values[19] = OpcodeCodings520_19; + asmError rv = ParseOperands(tokenBranches8592, operand); + return rv; } Coding x64Parser::OpcodeCodings521_19[] = { - {CODING_NAME("pand")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pand")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode521(x64Operand& operand) +asmError x64Parser::Opcode521(x64Operand &operand) { - operand.values[19] = OpcodeCodings521_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings521_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings522_19[] = { - {CODING_NAME("pandn")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pandn")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode522(x64Operand& operand) +asmError x64Parser::Opcode522(x64Operand &operand) { - operand.values[19] = OpcodeCodings522_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings522_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings523_19[] = { - {CODING_NAME("pavgb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pavgb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode523(x64Operand& operand) +asmError x64Parser::Opcode523(x64Operand &operand) { - operand.values[19] = OpcodeCodings523_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings523_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings524_19[] = { - {CODING_NAME("pavgw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pavgw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode524(x64Operand& operand) +asmError x64Parser::Opcode524(x64Operand &operand) { - operand.values[19] = OpcodeCodings524_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings524_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings525_23[] = { - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings525_19[] = { - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode525(x64Operand& operand) +asmError x64Parser::Opcode525(x64Operand &operand) { - operand.values[23] = OpcodeCodings525_23; - operand.values[19] = OpcodeCodings525_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings525_23; + operand.values[19] = OpcodeCodings525_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings526_19[] = { - {CODING_NAME("pcmpeqb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode526(x64Operand& operand) +asmError x64Parser::Opcode526(x64Operand &operand) { - operand.values[19] = OpcodeCodings526_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings526_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings527_19[] = { - {CODING_NAME("pcmpeqd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode527(x64Operand& operand) +asmError x64Parser::Opcode527(x64Operand &operand) { - operand.values[19] = OpcodeCodings527_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings527_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings528_19[] = { - {CODING_NAME("pcmpeqw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode528(x64Operand& operand) +asmError x64Parser::Opcode528(x64Operand &operand) { - operand.values[19] = OpcodeCodings528_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings528_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings529_23[] = { - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings529_19[] = { - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode529(x64Operand& operand) +asmError x64Parser::Opcode529(x64Operand &operand) { - operand.values[23] = OpcodeCodings529_23; - operand.values[19] = OpcodeCodings529_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings529_23; + operand.values[19] = OpcodeCodings529_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings530_23[] = { - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings530_19[] = { - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode530(x64Operand& operand) +asmError x64Parser::Opcode530(x64Operand &operand) { - operand.values[23] = OpcodeCodings530_23; - operand.values[19] = OpcodeCodings530_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings530_23; + operand.values[19] = OpcodeCodings530_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings531_19[] = { - {CODING_NAME("pcmpgtb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode531(x64Operand& operand) +asmError x64Parser::Opcode531(x64Operand &operand) { - operand.values[19] = OpcodeCodings531_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings531_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings532_19[] = { - {CODING_NAME("pcmpgtd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode532(x64Operand& operand) +asmError x64Parser::Opcode532(x64Operand &operand) { - operand.values[19] = OpcodeCodings532_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings532_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings533_19[] = { - {CODING_NAME("pcmpgtw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode533(x64Operand& operand) +asmError x64Parser::Opcode533(x64Operand &operand) { - operand.values[19] = OpcodeCodings533_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings533_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings534_19[] = { - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode534(x64Operand& operand) +asmError x64Parser::Opcode534(x64Operand &operand) { - operand.values[19] = OpcodeCodings534_19; - asmError rv = ParseOperands(tokenBranches8616, operand); - return rv; + operand.values[19] = OpcodeCodings534_19; + asmError rv = ParseOperands(tokenBranches8616, operand); + return rv; } Coding x64Parser::OpcodeCodings535_19[] = { - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode535(x64Operand& operand) +asmError x64Parser::Opcode535(x64Operand &operand) { - operand.values[19] = OpcodeCodings535_19; - asmError rv = ParseOperands(tokenBranches8622, operand); - return rv; + operand.values[19] = OpcodeCodings535_19; + asmError rv = ParseOperands(tokenBranches8622, operand); + return rv; } Coding x64Parser::OpcodeCodings536_19[] = { - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode536(x64Operand& operand) +asmError x64Parser::Opcode536(x64Operand &operand) { - operand.values[19] = OpcodeCodings536_19; - asmError rv = ParseOperands(tokenBranches8628, operand); - return rv; + operand.values[19] = OpcodeCodings536_19; + asmError rv = ParseOperands(tokenBranches8628, operand); + return rv; } -asmError x64Parser::Opcode537(x64Operand& operand) +asmError x64Parser::Opcode537(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8634, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8634, operand); + return rv; } Coding x64Parser::OpcodeCodings538_19[] = { - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode538(x64Operand& operand) +asmError x64Parser::Opcode538(x64Operand &operand) { - operand.values[19] = OpcodeCodings538_19; - asmError rv = ParseOperands(tokenBranches8655, operand); - return rv; + operand.values[19] = OpcodeCodings538_19; + asmError rv = ParseOperands(tokenBranches8655, operand); + return rv; } Coding x64Parser::OpcodeCodings539_19[] = { - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode539(x64Operand& operand) +asmError x64Parser::Opcode539(x64Operand &operand) { - operand.values[19] = OpcodeCodings539_19; - asmError rv = ParseOperands(tokenBranches8661, operand); - return rv; + operand.values[19] = OpcodeCodings539_19; + asmError rv = ParseOperands(tokenBranches8661, operand); + return rv; } Coding x64Parser::OpcodeCodings540_19[] = { - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode540(x64Operand& operand) +asmError x64Parser::Opcode540(x64Operand &operand) { - operand.values[19] = OpcodeCodings540_19; - asmError rv = ParseOperands(tokenBranches8667, operand); - return rv; + operand.values[19] = OpcodeCodings540_19; + asmError rv = ParseOperands(tokenBranches8667, operand); + return rv; } -asmError x64Parser::Opcode541(x64Operand& operand) +asmError x64Parser::Opcode541(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8673, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8673, operand); + return rv; } Coding x64Parser::OpcodeCodings542_19[] = { - {CODING_NAME("pmaddwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaddwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode542(x64Operand& operand) +asmError x64Parser::Opcode542(x64Operand &operand) { - operand.values[19] = OpcodeCodings542_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings542_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings543_19[] = { - {CODING_NAME("pmaxsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaxsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode543(x64Operand& operand) +asmError x64Parser::Opcode543(x64Operand &operand) { - operand.values[19] = OpcodeCodings543_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings543_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings544_19[] = { - {CODING_NAME("pmaxub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaxub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode544(x64Operand& operand) +asmError x64Parser::Opcode544(x64Operand &operand) { - operand.values[19] = OpcodeCodings544_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings544_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings545_19[] = { - {CODING_NAME("pminsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pminsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode545(x64Operand& operand) +asmError x64Parser::Opcode545(x64Operand &operand) { - operand.values[19] = OpcodeCodings545_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings545_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings546_19[] = { - {CODING_NAME("pminub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pminub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode546(x64Operand& operand) +asmError x64Parser::Opcode546(x64Operand &operand) { - operand.values[19] = OpcodeCodings546_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings546_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings547_19[] = { - {CODING_NAME("pmovmskb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmovmskb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode547(x64Operand& operand) +asmError x64Parser::Opcode547(x64Operand &operand) { - operand.values[19] = OpcodeCodings547_19; - asmError rv = ParseOperands(tokenBranches8699, operand); - return rv; + operand.values[19] = OpcodeCodings547_19; + asmError rv = ParseOperands(tokenBranches8699, operand); + return rv; } Coding x64Parser::OpcodeCodings548_19[] = { - {CODING_NAME("pmulhuw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmulhuw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode548(x64Operand& operand) +asmError x64Parser::Opcode548(x64Operand &operand) { - operand.values[19] = OpcodeCodings548_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings548_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings549_19[] = { - {CODING_NAME("pmulhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmulhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode549(x64Operand& operand) +asmError x64Parser::Opcode549(x64Operand &operand) { - operand.values[19] = OpcodeCodings549_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings549_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings550_19[] = { - {CODING_NAME("pmullw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmullw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode550(x64Operand& operand) +asmError x64Parser::Opcode550(x64Operand &operand) { - operand.values[19] = OpcodeCodings550_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings550_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings551_19[] = { - {CODING_NAME("pmuludq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmuludq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode551(x64Operand& operand) +asmError x64Parser::Opcode551(x64Operand &operand) { - operand.values[19] = OpcodeCodings551_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings551_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings552_19[] = { - {CODING_NAME("psadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode552(x64Operand& operand) +asmError x64Parser::Opcode552(x64Operand &operand) { - operand.values[19] = OpcodeCodings552_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings552_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings553_23[] = { - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings553_19[] = { - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode553(x64Operand& operand) +asmError x64Parser::Opcode553(x64Operand &operand) { - operand.values[23] = OpcodeCodings553_23; - operand.values[19] = OpcodeCodings553_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings553_23; + operand.values[19] = OpcodeCodings553_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings554_23[] = { - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings554_19[] = { - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode554(x64Operand& operand) +asmError x64Parser::Opcode554(x64Operand &operand) { - operand.values[23] = OpcodeCodings554_23; - operand.values[19] = OpcodeCodings554_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings554_23; + operand.values[19] = OpcodeCodings554_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings555_23[] = { - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings555_19[] = { - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode555(x64Operand& operand) +asmError x64Parser::Opcode555(x64Operand &operand) { - operand.values[23] = OpcodeCodings555_23; - operand.values[19] = OpcodeCodings555_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings555_23; + operand.values[19] = OpcodeCodings555_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings556_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings556_19[] = { - {CODING_NAME("pshufw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode556(x64Operand& operand) +asmError x64Parser::Opcode556(x64Operand &operand) { - operand.values[23] = OpcodeCodings556_23; - operand.values[19] = OpcodeCodings556_19; - asmError rv = ParseOperands(tokenBranches8720, operand); - return rv; + operand.values[23] = OpcodeCodings556_23; + operand.values[19] = OpcodeCodings556_19; + asmError rv = ParseOperands(tokenBranches8720, operand); + return rv; } Coding x64Parser::OpcodeCodings557_39[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings557_36[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings557_37[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode557(x64Operand& operand) +asmError x64Parser::Opcode557(x64Operand &operand) { - operand.values[39] = OpcodeCodings557_39; - operand.values[36] = OpcodeCodings557_36; - operand.values[37] = OpcodeCodings557_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings557_39; + operand.values[36] = OpcodeCodings557_36; + operand.values[37] = OpcodeCodings557_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings558_23[] = { - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings558_19[] = { - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode558(x64Operand& operand) +asmError x64Parser::Opcode558(x64Operand &operand) { - operand.values[23] = OpcodeCodings558_23; - operand.values[19] = OpcodeCodings558_19; - asmError rv = ParseOperands(tokenBranches8727, operand); - return rv; + operand.values[23] = OpcodeCodings558_23; + operand.values[19] = OpcodeCodings558_19; + asmError rv = ParseOperands(tokenBranches8727, operand); + return rv; } Coding x64Parser::OpcodeCodings559_39[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_36[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_37[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode559(x64Operand& operand) +asmError x64Parser::Opcode559(x64Operand &operand) { - operand.values[39] = OpcodeCodings559_39; - operand.values[36] = OpcodeCodings559_36; - operand.values[37] = OpcodeCodings559_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings559_39; + operand.values[36] = OpcodeCodings559_36; + operand.values[37] = OpcodeCodings559_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings560_39[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings560_36[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings560_37[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode560(x64Operand& operand) +asmError x64Parser::Opcode560(x64Operand &operand) { - operand.values[39] = OpcodeCodings560_39; - operand.values[36] = OpcodeCodings560_36; - operand.values[37] = OpcodeCodings560_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings560_39; + operand.values[36] = OpcodeCodings560_36; + operand.values[37] = OpcodeCodings560_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings561_39[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_36[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_37[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode561(x64Operand& operand) +asmError x64Parser::Opcode561(x64Operand &operand) { - operand.values[39] = OpcodeCodings561_39; - operand.values[36] = OpcodeCodings561_36; - operand.values[37] = OpcodeCodings561_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings561_39; + operand.values[36] = OpcodeCodings561_36; + operand.values[37] = OpcodeCodings561_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings562_39[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_36[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_37[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode562(x64Operand& operand) +asmError x64Parser::Opcode562(x64Operand &operand) { - operand.values[39] = OpcodeCodings562_39; - operand.values[36] = OpcodeCodings562_36; - operand.values[37] = OpcodeCodings562_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings562_39; + operand.values[36] = OpcodeCodings562_36; + operand.values[37] = OpcodeCodings562_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings563_39[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_36[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_37[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode563(x64Operand& operand) +asmError x64Parser::Opcode563(x64Operand &operand) { - operand.values[39] = OpcodeCodings563_39; - operand.values[36] = OpcodeCodings563_36; - operand.values[37] = OpcodeCodings563_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings563_39; + operand.values[36] = OpcodeCodings563_36; + operand.values[37] = OpcodeCodings563_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings564_23[] = { - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings564_19[] = { - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode564(x64Operand& operand) +asmError x64Parser::Opcode564(x64Operand &operand) { - operand.values[23] = OpcodeCodings564_23; - operand.values[19] = OpcodeCodings564_19; - asmError rv = ParseOperands(tokenBranches8736, operand); - return rv; + operand.values[23] = OpcodeCodings564_23; + operand.values[19] = OpcodeCodings564_19; + asmError rv = ParseOperands(tokenBranches8736, operand); + return rv; } Coding x64Parser::OpcodeCodings565_39[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_36[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_37[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode565(x64Operand& operand) +asmError x64Parser::Opcode565(x64Operand &operand) { - operand.values[39] = OpcodeCodings565_39; - operand.values[36] = OpcodeCodings565_36; - operand.values[37] = OpcodeCodings565_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings565_39; + operand.values[36] = OpcodeCodings565_36; + operand.values[37] = OpcodeCodings565_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings566_39[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings566_36[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings566_37[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode566(x64Operand& operand) +asmError x64Parser::Opcode566(x64Operand &operand) { - operand.values[39] = OpcodeCodings566_39; - operand.values[36] = OpcodeCodings566_36; - operand.values[37] = OpcodeCodings566_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings566_39; + operand.values[36] = OpcodeCodings566_36; + operand.values[37] = OpcodeCodings566_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings567_19[] = { - {CODING_NAME("psubb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode567(x64Operand& operand) +asmError x64Parser::Opcode567(x64Operand &operand) { - operand.values[19] = OpcodeCodings567_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings567_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings568_19[] = { - {CODING_NAME("psubd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode568(x64Operand& operand) +asmError x64Parser::Opcode568(x64Operand &operand) { - operand.values[19] = OpcodeCodings568_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings568_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings569_19[] = { - {CODING_NAME("psubq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode569(x64Operand& operand) +asmError x64Parser::Opcode569(x64Operand &operand) { - operand.values[19] = OpcodeCodings569_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings569_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings570_19[] = { - {CODING_NAME("psubsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode570(x64Operand& operand) +asmError x64Parser::Opcode570(x64Operand &operand) { - operand.values[19] = OpcodeCodings570_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings570_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings571_19[] = { - {CODING_NAME("psubsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode571(x64Operand& operand) +asmError x64Parser::Opcode571(x64Operand &operand) { - operand.values[19] = OpcodeCodings571_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings571_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings572_19[] = { - {CODING_NAME("psubusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode572(x64Operand& operand) +asmError x64Parser::Opcode572(x64Operand &operand) { - operand.values[19] = OpcodeCodings572_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings572_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings573_19[] = { - {CODING_NAME("psubusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode573(x64Operand& operand) +asmError x64Parser::Opcode573(x64Operand &operand) { - operand.values[19] = OpcodeCodings573_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings573_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings574_19[] = { - {CODING_NAME("punpckhbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode574(x64Operand& operand) +asmError x64Parser::Opcode574(x64Operand &operand) { - operand.values[19] = OpcodeCodings574_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings574_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings575_19[] = { - {CODING_NAME("punpckhdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode575(x64Operand& operand) +asmError x64Parser::Opcode575(x64Operand &operand) { - operand.values[19] = OpcodeCodings575_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings575_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings576_23[] = { - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings576_19[] = { - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode576(x64Operand& operand) +asmError x64Parser::Opcode576(x64Operand &operand) { - operand.values[23] = OpcodeCodings576_23; - operand.values[19] = OpcodeCodings576_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings576_23; + operand.values[19] = OpcodeCodings576_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings577_19[] = { - {CODING_NAME("punpckhwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode577(x64Operand& operand) +asmError x64Parser::Opcode577(x64Operand &operand) { - operand.values[19] = OpcodeCodings577_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings577_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings578_19[] = { - {CODING_NAME("punpcklbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode578(x64Operand& operand) +asmError x64Parser::Opcode578(x64Operand &operand) { - operand.values[19] = OpcodeCodings578_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings578_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings579_19[] = { - {CODING_NAME("punpckldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode579(x64Operand& operand) +asmError x64Parser::Opcode579(x64Operand &operand) { - operand.values[19] = OpcodeCodings579_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings579_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings580_23[] = { - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings580_19[] = { - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode580(x64Operand& operand) +asmError x64Parser::Opcode580(x64Operand &operand) { - operand.values[23] = OpcodeCodings580_23; - operand.values[19] = OpcodeCodings580_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings580_23; + operand.values[19] = OpcodeCodings580_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings581_19[] = { - {CODING_NAME("punpcklwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode581(x64Operand& operand) +asmError x64Parser::Opcode581(x64Operand &operand) { - operand.values[19] = OpcodeCodings581_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings581_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings582_19[] = { - {CODING_NAME("pxor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pxor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode582(x64Operand& operand) +asmError x64Parser::Opcode582(x64Operand &operand) { - operand.values[19] = OpcodeCodings582_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings582_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings583_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings583_19[] = { - {CODING_NAME("rcpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rcpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode583(x64Operand& operand) +asmError x64Parser::Opcode583(x64Operand &operand) { - operand.values[23] = OpcodeCodings583_23; - operand.values[19] = OpcodeCodings583_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings583_23; + operand.values[19] = OpcodeCodings583_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings584_23[] = { - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings584_19[] = { - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode584(x64Operand& operand) +asmError x64Parser::Opcode584(x64Operand &operand) { - operand.values[23] = OpcodeCodings584_23; - operand.values[19] = OpcodeCodings584_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings584_23; + operand.values[19] = OpcodeCodings584_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings585_23[] = { - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings585_19[] = { - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode585(x64Operand& operand) +asmError x64Parser::Opcode585(x64Operand &operand) { - operand.values[23] = OpcodeCodings585_23; - operand.values[19] = OpcodeCodings585_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings585_23; + operand.values[19] = OpcodeCodings585_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings586_23[] = { - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings586_19[] = { - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode586(x64Operand& operand) +asmError x64Parser::Opcode586(x64Operand &operand) { - operand.values[23] = OpcodeCodings586_23; - operand.values[19] = OpcodeCodings586_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings586_23; + operand.values[19] = OpcodeCodings586_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings587_23[] = { - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings587_19[] = { - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode587(x64Operand& operand) +asmError x64Parser::Opcode587(x64Operand &operand) { - operand.values[23] = OpcodeCodings587_23; - operand.values[19] = OpcodeCodings587_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings587_23; + operand.values[19] = OpcodeCodings587_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings588_23[] = { - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings588_19[] = { - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode588(x64Operand& operand) +asmError x64Parser::Opcode588(x64Operand &operand) { - operand.values[23] = OpcodeCodings588_23; - operand.values[19] = OpcodeCodings588_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings588_23; + operand.values[19] = OpcodeCodings588_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings589_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings589_19[] = { - {CODING_NAME("rsqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rsqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode589(x64Operand& operand) +asmError x64Parser::Opcode589(x64Operand &operand) { - operand.values[23] = OpcodeCodings589_23; - operand.values[19] = OpcodeCodings589_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings589_23; + operand.values[19] = OpcodeCodings589_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings590_23[] = { - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings590_19[] = { - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode590(x64Operand& operand) +asmError x64Parser::Opcode590(x64Operand &operand) { - operand.values[23] = OpcodeCodings590_23; - operand.values[19] = OpcodeCodings590_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings590_23; + operand.values[19] = OpcodeCodings590_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings591_23[] = { - {CODING_NAME("shufpd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings591_19[] = { - {CODING_NAME("shufpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("shufpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode591(x64Operand& operand) +asmError x64Parser::Opcode591(x64Operand &operand) { - operand.values[23] = OpcodeCodings591_23; - operand.values[19] = OpcodeCodings591_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings591_23; + operand.values[19] = OpcodeCodings591_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings592_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings592_19[] = { - {CODING_NAME("shufps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("shufps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode592(x64Operand& operand) +asmError x64Parser::Opcode592(x64Operand &operand) { - operand.values[23] = OpcodeCodings592_23; - operand.values[19] = OpcodeCodings592_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings592_23; + operand.values[19] = OpcodeCodings592_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings593_23[] = { - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings593_19[] = { - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode593(x64Operand& operand) +asmError x64Parser::Opcode593(x64Operand &operand) { - operand.values[23] = OpcodeCodings593_23; - operand.values[19] = OpcodeCodings593_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings593_23; + operand.values[19] = OpcodeCodings593_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings594_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings594_19[] = { - {CODING_NAME("sqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode594(x64Operand& operand) +asmError x64Parser::Opcode594(x64Operand &operand) { - operand.values[23] = OpcodeCodings594_23; - operand.values[19] = OpcodeCodings594_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings594_23; + operand.values[19] = OpcodeCodings594_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings595_23[] = { - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings595_19[] = { - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode595(x64Operand& operand) +asmError x64Parser::Opcode595(x64Operand &operand) { - operand.values[23] = OpcodeCodings595_23; - operand.values[19] = OpcodeCodings595_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings595_23; + operand.values[19] = OpcodeCodings595_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings596_23[] = { - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings596_19[] = { - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode596(x64Operand& operand) +asmError x64Parser::Opcode596(x64Operand &operand) { - operand.values[23] = OpcodeCodings596_23; - operand.values[19] = OpcodeCodings596_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings596_23; + operand.values[19] = OpcodeCodings596_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings597_23[] = { - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings597_19[] = { - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode597(x64Operand& operand) +asmError x64Parser::Opcode597(x64Operand &operand) { - operand.values[23] = OpcodeCodings597_23; - operand.values[19] = OpcodeCodings597_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings597_23; + operand.values[19] = OpcodeCodings597_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings598_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings598_19[] = { - {CODING_NAME("subps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode598(x64Operand& operand) +asmError x64Parser::Opcode598(x64Operand &operand) { - operand.values[23] = OpcodeCodings598_23; - operand.values[19] = OpcodeCodings598_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings598_23; + operand.values[19] = OpcodeCodings598_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings599_23[] = { - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings599_19[] = { - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode599(x64Operand& operand) +asmError x64Parser::Opcode599(x64Operand &operand) { - operand.values[23] = OpcodeCodings599_23; - operand.values[19] = OpcodeCodings599_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings599_23; + operand.values[19] = OpcodeCodings599_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings600_23[] = { - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings600_19[] = { - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode600(x64Operand& operand) +asmError x64Parser::Opcode600(x64Operand &operand) { - operand.values[23] = OpcodeCodings600_23; - operand.values[19] = OpcodeCodings600_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings600_23; + operand.values[19] = OpcodeCodings600_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings601_23[] = { - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings601_19[] = { - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode601(x64Operand& operand) +asmError x64Parser::Opcode601(x64Operand &operand) { - operand.values[23] = OpcodeCodings601_23; - operand.values[19] = OpcodeCodings601_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings601_23; + operand.values[19] = OpcodeCodings601_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings602_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings602_19[] = { - {CODING_NAME("ucomiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ucomiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode602(x64Operand& operand) +asmError x64Parser::Opcode602(x64Operand &operand) { - operand.values[23] = OpcodeCodings602_23; - operand.values[19] = OpcodeCodings602_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings602_23; + operand.values[19] = OpcodeCodings602_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings603_23[] = { - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings603_19[] = { - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode603(x64Operand& operand) +asmError x64Parser::Opcode603(x64Operand &operand) { - operand.values[23] = OpcodeCodings603_23; - operand.values[19] = OpcodeCodings603_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings603_23; + operand.values[19] = OpcodeCodings603_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings604_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings604_19[] = { - {CODING_NAME("unpckhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpckhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode604(x64Operand& operand) +asmError x64Parser::Opcode604(x64Operand &operand) { - operand.values[23] = OpcodeCodings604_23; - operand.values[19] = OpcodeCodings604_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings604_23; + operand.values[19] = OpcodeCodings604_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings605_23[] = { - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings605_19[] = { - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode605(x64Operand& operand) +asmError x64Parser::Opcode605(x64Operand &operand) { - operand.values[23] = OpcodeCodings605_23; - operand.values[19] = OpcodeCodings605_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings605_23; + operand.values[19] = OpcodeCodings605_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings606_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings606_19[] = { - {CODING_NAME("unpcklps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpcklps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode606(x64Operand& operand) +asmError x64Parser::Opcode606(x64Operand &operand) { - operand.values[23] = OpcodeCodings606_23; - operand.values[19] = OpcodeCodings606_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings606_23; + operand.values[19] = OpcodeCodings606_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings607_23[] = { - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings607_19[] = { - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode607(x64Operand& operand) +asmError x64Parser::Opcode607(x64Operand &operand) { - operand.values[23] = OpcodeCodings607_23; - operand.values[19] = OpcodeCodings607_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings607_23; + operand.values[19] = OpcodeCodings607_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings608_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings608_19[] = { - {CODING_NAME("xorps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("xorps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode608(x64Operand& operand) +asmError x64Parser::Opcode608(x64Operand &operand) { - operand.values[23] = OpcodeCodings608_23; - operand.values[19] = OpcodeCodings608_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings608_23; + operand.values[19] = OpcodeCodings608_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } -asmError x64Parser::Opcode609(x64Operand& operand) +asmError x64Parser::Opcode609(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode610(x64Operand& operand) +asmError x64Parser::Opcode610(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode611(x64Operand& operand) +asmError x64Parser::Opcode611(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode612(x64Operand& operand) +asmError x64Parser::Opcode612(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode613(x64Operand& operand) +asmError x64Parser::Opcode613(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode614(x64Operand& operand) +asmError x64Parser::Opcode614(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode615(x64Operand& operand) +asmError x64Parser::Opcode615(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode616(x64Operand& operand) +asmError x64Parser::Opcode616(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode617(x64Operand& operand) +asmError x64Parser::Opcode617(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode618(x64Operand& operand) +asmError x64Parser::Opcode618(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode619(x64Operand& operand) +asmError x64Parser::Opcode619(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode620(x64Operand& operand) +asmError x64Parser::Opcode620(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } x64Parser::DispatchType x64Parser::DispatchTable[621] = { - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - &x64Parser::Opcode32, - &x64Parser::Opcode33, - &x64Parser::Opcode34, - &x64Parser::Opcode35, - &x64Parser::Opcode36, - &x64Parser::Opcode37, - &x64Parser::Opcode38, - &x64Parser::Opcode39, - &x64Parser::Opcode40, - &x64Parser::Opcode41, - &x64Parser::Opcode42, - &x64Parser::Opcode43, - &x64Parser::Opcode44, - &x64Parser::Opcode45, - &x64Parser::Opcode46, - &x64Parser::Opcode47, - &x64Parser::Opcode48, - &x64Parser::Opcode49, - &x64Parser::Opcode50, - &x64Parser::Opcode51, - &x64Parser::Opcode52, - &x64Parser::Opcode53, - &x64Parser::Opcode54, - &x64Parser::Opcode55, - &x64Parser::Opcode56, - &x64Parser::Opcode57, - &x64Parser::Opcode58, - &x64Parser::Opcode59, - &x64Parser::Opcode60, - &x64Parser::Opcode61, - &x64Parser::Opcode62, - &x64Parser::Opcode63, - &x64Parser::Opcode64, - &x64Parser::Opcode65, - &x64Parser::Opcode66, - &x64Parser::Opcode67, - &x64Parser::Opcode68, - &x64Parser::Opcode69, - &x64Parser::Opcode70, - &x64Parser::Opcode71, - &x64Parser::Opcode72, - &x64Parser::Opcode73, - &x64Parser::Opcode74, - &x64Parser::Opcode75, - &x64Parser::Opcode76, - &x64Parser::Opcode77, - &x64Parser::Opcode78, - &x64Parser::Opcode79, - &x64Parser::Opcode80, - &x64Parser::Opcode81, - &x64Parser::Opcode82, - &x64Parser::Opcode83, - &x64Parser::Opcode84, - &x64Parser::Opcode85, - &x64Parser::Opcode86, - &x64Parser::Opcode87, - &x64Parser::Opcode88, - &x64Parser::Opcode89, - &x64Parser::Opcode90, - &x64Parser::Opcode91, - &x64Parser::Opcode92, - &x64Parser::Opcode93, - &x64Parser::Opcode94, - &x64Parser::Opcode95, - &x64Parser::Opcode96, - &x64Parser::Opcode97, - &x64Parser::Opcode98, - &x64Parser::Opcode99, - &x64Parser::Opcode100, - &x64Parser::Opcode101, - &x64Parser::Opcode102, - &x64Parser::Opcode103, - &x64Parser::Opcode104, - &x64Parser::Opcode105, - &x64Parser::Opcode106, - &x64Parser::Opcode107, - &x64Parser::Opcode108, - &x64Parser::Opcode109, - &x64Parser::Opcode110, - &x64Parser::Opcode111, - &x64Parser::Opcode112, - &x64Parser::Opcode113, - &x64Parser::Opcode114, - &x64Parser::Opcode115, - &x64Parser::Opcode116, - &x64Parser::Opcode117, - &x64Parser::Opcode118, - &x64Parser::Opcode119, - &x64Parser::Opcode120, - &x64Parser::Opcode121, - &x64Parser::Opcode122, - &x64Parser::Opcode123, - &x64Parser::Opcode124, - &x64Parser::Opcode125, - &x64Parser::Opcode126, - &x64Parser::Opcode127, - &x64Parser::Opcode128, - &x64Parser::Opcode129, - &x64Parser::Opcode130, - &x64Parser::Opcode131, - &x64Parser::Opcode132, - &x64Parser::Opcode133, - &x64Parser::Opcode134, - &x64Parser::Opcode135, - &x64Parser::Opcode136, - &x64Parser::Opcode137, - &x64Parser::Opcode138, - &x64Parser::Opcode139, - &x64Parser::Opcode140, - &x64Parser::Opcode141, - &x64Parser::Opcode142, - &x64Parser::Opcode143, - &x64Parser::Opcode144, - &x64Parser::Opcode145, - &x64Parser::Opcode146, - &x64Parser::Opcode147, - &x64Parser::Opcode148, - &x64Parser::Opcode149, - &x64Parser::Opcode150, - &x64Parser::Opcode151, - &x64Parser::Opcode152, - &x64Parser::Opcode153, - &x64Parser::Opcode154, - &x64Parser::Opcode155, - &x64Parser::Opcode156, - &x64Parser::Opcode157, - &x64Parser::Opcode158, - &x64Parser::Opcode159, - &x64Parser::Opcode160, - &x64Parser::Opcode161, - &x64Parser::Opcode162, - &x64Parser::Opcode163, - &x64Parser::Opcode164, - &x64Parser::Opcode165, - &x64Parser::Opcode166, - &x64Parser::Opcode167, - &x64Parser::Opcode168, - &x64Parser::Opcode169, - &x64Parser::Opcode170, - &x64Parser::Opcode171, - &x64Parser::Opcode172, - &x64Parser::Opcode173, - &x64Parser::Opcode174, - &x64Parser::Opcode175, - &x64Parser::Opcode176, - &x64Parser::Opcode177, - &x64Parser::Opcode178, - &x64Parser::Opcode179, - &x64Parser::Opcode180, - &x64Parser::Opcode181, - &x64Parser::Opcode182, - &x64Parser::Opcode183, - &x64Parser::Opcode184, - &x64Parser::Opcode185, - &x64Parser::Opcode186, - &x64Parser::Opcode187, - &x64Parser::Opcode188, - &x64Parser::Opcode189, - &x64Parser::Opcode190, - &x64Parser::Opcode191, - &x64Parser::Opcode192, - &x64Parser::Opcode193, - &x64Parser::Opcode194, - &x64Parser::Opcode195, - &x64Parser::Opcode196, - &x64Parser::Opcode197, - &x64Parser::Opcode198, - &x64Parser::Opcode199, - &x64Parser::Opcode200, - &x64Parser::Opcode201, - &x64Parser::Opcode202, - &x64Parser::Opcode203, - &x64Parser::Opcode204, - &x64Parser::Opcode205, - &x64Parser::Opcode206, - &x64Parser::Opcode207, - &x64Parser::Opcode208, - &x64Parser::Opcode209, - &x64Parser::Opcode210, - &x64Parser::Opcode211, - &x64Parser::Opcode212, - &x64Parser::Opcode213, - &x64Parser::Opcode214, - &x64Parser::Opcode215, - &x64Parser::Opcode216, - &x64Parser::Opcode217, - &x64Parser::Opcode218, - &x64Parser::Opcode219, - &x64Parser::Opcode220, - &x64Parser::Opcode221, - &x64Parser::Opcode222, - &x64Parser::Opcode223, - &x64Parser::Opcode224, - &x64Parser::Opcode225, - &x64Parser::Opcode226, - &x64Parser::Opcode227, - &x64Parser::Opcode228, - &x64Parser::Opcode229, - &x64Parser::Opcode230, - &x64Parser::Opcode231, - &x64Parser::Opcode232, - &x64Parser::Opcode233, - &x64Parser::Opcode234, - &x64Parser::Opcode235, - &x64Parser::Opcode236, - &x64Parser::Opcode237, - &x64Parser::Opcode238, - &x64Parser::Opcode239, - &x64Parser::Opcode240, - &x64Parser::Opcode241, - &x64Parser::Opcode242, - &x64Parser::Opcode243, - &x64Parser::Opcode244, - &x64Parser::Opcode245, - &x64Parser::Opcode246, - &x64Parser::Opcode247, - &x64Parser::Opcode248, - &x64Parser::Opcode249, - &x64Parser::Opcode250, - &x64Parser::Opcode251, - &x64Parser::Opcode252, - &x64Parser::Opcode253, - &x64Parser::Opcode254, - &x64Parser::Opcode255, - &x64Parser::Opcode256, - &x64Parser::Opcode257, - &x64Parser::Opcode258, - &x64Parser::Opcode259, - &x64Parser::Opcode260, - &x64Parser::Opcode261, - &x64Parser::Opcode262, - &x64Parser::Opcode263, - &x64Parser::Opcode264, - &x64Parser::Opcode265, - &x64Parser::Opcode266, - &x64Parser::Opcode267, - &x64Parser::Opcode268, - &x64Parser::Opcode269, - &x64Parser::Opcode270, - &x64Parser::Opcode271, - &x64Parser::Opcode272, - &x64Parser::Opcode273, - &x64Parser::Opcode274, - &x64Parser::Opcode275, - &x64Parser::Opcode276, - &x64Parser::Opcode277, - &x64Parser::Opcode278, - &x64Parser::Opcode279, - &x64Parser::Opcode280, - &x64Parser::Opcode281, - &x64Parser::Opcode282, - &x64Parser::Opcode283, - &x64Parser::Opcode284, - &x64Parser::Opcode285, - &x64Parser::Opcode286, - &x64Parser::Opcode287, - &x64Parser::Opcode288, - &x64Parser::Opcode289, - &x64Parser::Opcode290, - &x64Parser::Opcode291, - &x64Parser::Opcode292, - &x64Parser::Opcode293, - &x64Parser::Opcode294, - &x64Parser::Opcode295, - &x64Parser::Opcode296, - &x64Parser::Opcode297, - &x64Parser::Opcode298, - &x64Parser::Opcode299, - &x64Parser::Opcode300, - &x64Parser::Opcode301, - &x64Parser::Opcode302, - &x64Parser::Opcode303, - &x64Parser::Opcode304, - &x64Parser::Opcode305, - &x64Parser::Opcode306, - &x64Parser::Opcode307, - &x64Parser::Opcode308, - &x64Parser::Opcode309, - &x64Parser::Opcode310, - &x64Parser::Opcode311, - &x64Parser::Opcode312, - &x64Parser::Opcode313, - &x64Parser::Opcode314, - &x64Parser::Opcode315, - &x64Parser::Opcode316, - &x64Parser::Opcode317, - &x64Parser::Opcode318, - &x64Parser::Opcode319, - &x64Parser::Opcode320, - &x64Parser::Opcode321, - &x64Parser::Opcode322, - &x64Parser::Opcode323, - &x64Parser::Opcode324, - &x64Parser::Opcode325, - &x64Parser::Opcode326, - &x64Parser::Opcode327, - &x64Parser::Opcode328, - &x64Parser::Opcode329, - &x64Parser::Opcode330, - &x64Parser::Opcode331, - &x64Parser::Opcode332, - &x64Parser::Opcode333, - &x64Parser::Opcode334, - &x64Parser::Opcode335, - &x64Parser::Opcode336, - &x64Parser::Opcode337, - &x64Parser::Opcode338, - &x64Parser::Opcode339, - &x64Parser::Opcode340, - &x64Parser::Opcode341, - &x64Parser::Opcode342, - &x64Parser::Opcode343, - &x64Parser::Opcode344, - &x64Parser::Opcode345, - &x64Parser::Opcode346, - &x64Parser::Opcode347, - &x64Parser::Opcode348, - &x64Parser::Opcode349, - &x64Parser::Opcode350, - &x64Parser::Opcode351, - &x64Parser::Opcode352, - &x64Parser::Opcode353, - &x64Parser::Opcode354, - &x64Parser::Opcode355, - &x64Parser::Opcode356, - &x64Parser::Opcode357, - &x64Parser::Opcode358, - &x64Parser::Opcode359, - &x64Parser::Opcode360, - &x64Parser::Opcode361, - &x64Parser::Opcode362, - &x64Parser::Opcode363, - &x64Parser::Opcode364, - &x64Parser::Opcode365, - &x64Parser::Opcode366, - &x64Parser::Opcode367, - &x64Parser::Opcode368, - &x64Parser::Opcode369, - &x64Parser::Opcode370, - &x64Parser::Opcode371, - &x64Parser::Opcode372, - &x64Parser::Opcode373, - &x64Parser::Opcode374, - &x64Parser::Opcode375, - &x64Parser::Opcode376, - &x64Parser::Opcode377, - &x64Parser::Opcode378, - &x64Parser::Opcode379, - &x64Parser::Opcode380, - &x64Parser::Opcode381, - &x64Parser::Opcode382, - &x64Parser::Opcode383, - &x64Parser::Opcode384, - &x64Parser::Opcode385, - &x64Parser::Opcode386, - &x64Parser::Opcode387, - &x64Parser::Opcode388, - &x64Parser::Opcode389, - &x64Parser::Opcode390, - &x64Parser::Opcode391, - &x64Parser::Opcode392, - &x64Parser::Opcode393, - &x64Parser::Opcode394, - &x64Parser::Opcode395, - &x64Parser::Opcode396, - &x64Parser::Opcode397, - &x64Parser::Opcode398, - &x64Parser::Opcode399, - &x64Parser::Opcode400, - &x64Parser::Opcode401, - &x64Parser::Opcode402, - &x64Parser::Opcode403, - &x64Parser::Opcode404, - &x64Parser::Opcode405, - &x64Parser::Opcode406, - &x64Parser::Opcode407, - &x64Parser::Opcode408, - &x64Parser::Opcode409, - &x64Parser::Opcode410, - &x64Parser::Opcode411, - &x64Parser::Opcode412, - &x64Parser::Opcode413, - &x64Parser::Opcode414, - &x64Parser::Opcode415, - &x64Parser::Opcode416, - &x64Parser::Opcode417, - &x64Parser::Opcode418, - &x64Parser::Opcode419, - &x64Parser::Opcode420, - &x64Parser::Opcode421, - &x64Parser::Opcode422, - &x64Parser::Opcode423, - &x64Parser::Opcode424, - &x64Parser::Opcode425, - &x64Parser::Opcode426, - &x64Parser::Opcode427, - &x64Parser::Opcode428, - &x64Parser::Opcode429, - &x64Parser::Opcode430, - &x64Parser::Opcode431, - &x64Parser::Opcode432, - &x64Parser::Opcode433, - &x64Parser::Opcode434, - &x64Parser::Opcode435, - &x64Parser::Opcode436, - &x64Parser::Opcode437, - &x64Parser::Opcode438, - &x64Parser::Opcode439, - &x64Parser::Opcode440, - &x64Parser::Opcode441, - &x64Parser::Opcode442, - &x64Parser::Opcode443, - &x64Parser::Opcode444, - &x64Parser::Opcode445, - &x64Parser::Opcode446, - &x64Parser::Opcode447, - &x64Parser::Opcode448, - &x64Parser::Opcode449, - &x64Parser::Opcode450, - &x64Parser::Opcode451, - &x64Parser::Opcode452, - &x64Parser::Opcode453, - &x64Parser::Opcode454, - &x64Parser::Opcode455, - &x64Parser::Opcode456, - &x64Parser::Opcode457, - &x64Parser::Opcode458, - &x64Parser::Opcode459, - &x64Parser::Opcode460, - &x64Parser::Opcode461, - &x64Parser::Opcode462, - &x64Parser::Opcode463, - &x64Parser::Opcode464, - &x64Parser::Opcode465, - &x64Parser::Opcode466, - &x64Parser::Opcode467, - &x64Parser::Opcode468, - &x64Parser::Opcode469, - &x64Parser::Opcode470, - &x64Parser::Opcode471, - &x64Parser::Opcode472, - &x64Parser::Opcode473, - &x64Parser::Opcode474, - &x64Parser::Opcode475, - &x64Parser::Opcode476, - &x64Parser::Opcode477, - &x64Parser::Opcode478, - &x64Parser::Opcode479, - &x64Parser::Opcode480, - &x64Parser::Opcode481, - &x64Parser::Opcode482, - &x64Parser::Opcode483, - &x64Parser::Opcode484, - &x64Parser::Opcode485, - &x64Parser::Opcode486, - &x64Parser::Opcode487, - &x64Parser::Opcode488, - &x64Parser::Opcode489, - &x64Parser::Opcode490, - &x64Parser::Opcode491, - &x64Parser::Opcode492, - &x64Parser::Opcode493, - &x64Parser::Opcode494, - &x64Parser::Opcode495, - &x64Parser::Opcode496, - &x64Parser::Opcode497, - &x64Parser::Opcode498, - &x64Parser::Opcode499, - &x64Parser::Opcode500, - &x64Parser::Opcode501, - &x64Parser::Opcode502, - &x64Parser::Opcode503, - &x64Parser::Opcode504, - &x64Parser::Opcode505, - &x64Parser::Opcode506, - &x64Parser::Opcode507, - &x64Parser::Opcode508, - &x64Parser::Opcode509, - &x64Parser::Opcode510, - &x64Parser::Opcode511, - &x64Parser::Opcode512, - &x64Parser::Opcode513, - &x64Parser::Opcode514, - &x64Parser::Opcode515, - &x64Parser::Opcode516, - &x64Parser::Opcode517, - &x64Parser::Opcode518, - &x64Parser::Opcode519, - &x64Parser::Opcode520, - &x64Parser::Opcode521, - &x64Parser::Opcode522, - &x64Parser::Opcode523, - &x64Parser::Opcode524, - &x64Parser::Opcode525, - &x64Parser::Opcode526, - &x64Parser::Opcode527, - &x64Parser::Opcode528, - &x64Parser::Opcode529, - &x64Parser::Opcode530, - &x64Parser::Opcode531, - &x64Parser::Opcode532, - &x64Parser::Opcode533, - &x64Parser::Opcode534, - &x64Parser::Opcode535, - &x64Parser::Opcode536, - &x64Parser::Opcode537, - &x64Parser::Opcode538, - &x64Parser::Opcode539, - &x64Parser::Opcode540, - &x64Parser::Opcode541, - &x64Parser::Opcode542, - &x64Parser::Opcode543, - &x64Parser::Opcode544, - &x64Parser::Opcode545, - &x64Parser::Opcode546, - &x64Parser::Opcode547, - &x64Parser::Opcode548, - &x64Parser::Opcode549, - &x64Parser::Opcode550, - &x64Parser::Opcode551, - &x64Parser::Opcode552, - &x64Parser::Opcode553, - &x64Parser::Opcode554, - &x64Parser::Opcode555, - &x64Parser::Opcode556, - &x64Parser::Opcode557, - &x64Parser::Opcode558, - &x64Parser::Opcode559, - &x64Parser::Opcode560, - &x64Parser::Opcode561, - &x64Parser::Opcode562, - &x64Parser::Opcode563, - &x64Parser::Opcode564, - &x64Parser::Opcode565, - &x64Parser::Opcode566, - &x64Parser::Opcode567, - &x64Parser::Opcode568, - &x64Parser::Opcode569, - &x64Parser::Opcode570, - &x64Parser::Opcode571, - &x64Parser::Opcode572, - &x64Parser::Opcode573, - &x64Parser::Opcode574, - &x64Parser::Opcode575, - &x64Parser::Opcode576, - &x64Parser::Opcode577, - &x64Parser::Opcode578, - &x64Parser::Opcode579, - &x64Parser::Opcode580, - &x64Parser::Opcode581, - &x64Parser::Opcode582, - &x64Parser::Opcode583, - &x64Parser::Opcode584, - &x64Parser::Opcode585, - &x64Parser::Opcode586, - &x64Parser::Opcode587, - &x64Parser::Opcode588, - &x64Parser::Opcode589, - &x64Parser::Opcode590, - &x64Parser::Opcode591, - &x64Parser::Opcode592, - &x64Parser::Opcode593, - &x64Parser::Opcode594, - &x64Parser::Opcode595, - &x64Parser::Opcode596, - &x64Parser::Opcode597, - &x64Parser::Opcode598, - &x64Parser::Opcode599, - &x64Parser::Opcode600, - &x64Parser::Opcode601, - &x64Parser::Opcode602, - &x64Parser::Opcode603, - &x64Parser::Opcode604, - &x64Parser::Opcode605, - &x64Parser::Opcode606, - &x64Parser::Opcode607, - &x64Parser::Opcode608, - &x64Parser::Opcode609, - &x64Parser::Opcode610, - &x64Parser::Opcode611, - &x64Parser::Opcode612, - &x64Parser::Opcode613, - &x64Parser::Opcode614, - &x64Parser::Opcode615, - &x64Parser::Opcode616, - &x64Parser::Opcode617, - &x64Parser::Opcode618, - &x64Parser::Opcode619, - &x64Parser::Opcode620, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + &x64Parser::Opcode32, + &x64Parser::Opcode33, + &x64Parser::Opcode34, + &x64Parser::Opcode35, + &x64Parser::Opcode36, + &x64Parser::Opcode37, + &x64Parser::Opcode38, + &x64Parser::Opcode39, + &x64Parser::Opcode40, + &x64Parser::Opcode41, + &x64Parser::Opcode42, + &x64Parser::Opcode43, + &x64Parser::Opcode44, + &x64Parser::Opcode45, + &x64Parser::Opcode46, + &x64Parser::Opcode47, + &x64Parser::Opcode48, + &x64Parser::Opcode49, + &x64Parser::Opcode50, + &x64Parser::Opcode51, + &x64Parser::Opcode52, + &x64Parser::Opcode53, + &x64Parser::Opcode54, + &x64Parser::Opcode55, + &x64Parser::Opcode56, + &x64Parser::Opcode57, + &x64Parser::Opcode58, + &x64Parser::Opcode59, + &x64Parser::Opcode60, + &x64Parser::Opcode61, + &x64Parser::Opcode62, + &x64Parser::Opcode63, + &x64Parser::Opcode64, + &x64Parser::Opcode65, + &x64Parser::Opcode66, + &x64Parser::Opcode67, + &x64Parser::Opcode68, + &x64Parser::Opcode69, + &x64Parser::Opcode70, + &x64Parser::Opcode71, + &x64Parser::Opcode72, + &x64Parser::Opcode73, + &x64Parser::Opcode74, + &x64Parser::Opcode75, + &x64Parser::Opcode76, + &x64Parser::Opcode77, + &x64Parser::Opcode78, + &x64Parser::Opcode79, + &x64Parser::Opcode80, + &x64Parser::Opcode81, + &x64Parser::Opcode82, + &x64Parser::Opcode83, + &x64Parser::Opcode84, + &x64Parser::Opcode85, + &x64Parser::Opcode86, + &x64Parser::Opcode87, + &x64Parser::Opcode88, + &x64Parser::Opcode89, + &x64Parser::Opcode90, + &x64Parser::Opcode91, + &x64Parser::Opcode92, + &x64Parser::Opcode93, + &x64Parser::Opcode94, + &x64Parser::Opcode95, + &x64Parser::Opcode96, + &x64Parser::Opcode97, + &x64Parser::Opcode98, + &x64Parser::Opcode99, + &x64Parser::Opcode100, + &x64Parser::Opcode101, + &x64Parser::Opcode102, + &x64Parser::Opcode103, + &x64Parser::Opcode104, + &x64Parser::Opcode105, + &x64Parser::Opcode106, + &x64Parser::Opcode107, + &x64Parser::Opcode108, + &x64Parser::Opcode109, + &x64Parser::Opcode110, + &x64Parser::Opcode111, + &x64Parser::Opcode112, + &x64Parser::Opcode113, + &x64Parser::Opcode114, + &x64Parser::Opcode115, + &x64Parser::Opcode116, + &x64Parser::Opcode117, + &x64Parser::Opcode118, + &x64Parser::Opcode119, + &x64Parser::Opcode120, + &x64Parser::Opcode121, + &x64Parser::Opcode122, + &x64Parser::Opcode123, + &x64Parser::Opcode124, + &x64Parser::Opcode125, + &x64Parser::Opcode126, + &x64Parser::Opcode127, + &x64Parser::Opcode128, + &x64Parser::Opcode129, + &x64Parser::Opcode130, + &x64Parser::Opcode131, + &x64Parser::Opcode132, + &x64Parser::Opcode133, + &x64Parser::Opcode134, + &x64Parser::Opcode135, + &x64Parser::Opcode136, + &x64Parser::Opcode137, + &x64Parser::Opcode138, + &x64Parser::Opcode139, + &x64Parser::Opcode140, + &x64Parser::Opcode141, + &x64Parser::Opcode142, + &x64Parser::Opcode143, + &x64Parser::Opcode144, + &x64Parser::Opcode145, + &x64Parser::Opcode146, + &x64Parser::Opcode147, + &x64Parser::Opcode148, + &x64Parser::Opcode149, + &x64Parser::Opcode150, + &x64Parser::Opcode151, + &x64Parser::Opcode152, + &x64Parser::Opcode153, + &x64Parser::Opcode154, + &x64Parser::Opcode155, + &x64Parser::Opcode156, + &x64Parser::Opcode157, + &x64Parser::Opcode158, + &x64Parser::Opcode159, + &x64Parser::Opcode160, + &x64Parser::Opcode161, + &x64Parser::Opcode162, + &x64Parser::Opcode163, + &x64Parser::Opcode164, + &x64Parser::Opcode165, + &x64Parser::Opcode166, + &x64Parser::Opcode167, + &x64Parser::Opcode168, + &x64Parser::Opcode169, + &x64Parser::Opcode170, + &x64Parser::Opcode171, + &x64Parser::Opcode172, + &x64Parser::Opcode173, + &x64Parser::Opcode174, + &x64Parser::Opcode175, + &x64Parser::Opcode176, + &x64Parser::Opcode177, + &x64Parser::Opcode178, + &x64Parser::Opcode179, + &x64Parser::Opcode180, + &x64Parser::Opcode181, + &x64Parser::Opcode182, + &x64Parser::Opcode183, + &x64Parser::Opcode184, + &x64Parser::Opcode185, + &x64Parser::Opcode186, + &x64Parser::Opcode187, + &x64Parser::Opcode188, + &x64Parser::Opcode189, + &x64Parser::Opcode190, + &x64Parser::Opcode191, + &x64Parser::Opcode192, + &x64Parser::Opcode193, + &x64Parser::Opcode194, + &x64Parser::Opcode195, + &x64Parser::Opcode196, + &x64Parser::Opcode197, + &x64Parser::Opcode198, + &x64Parser::Opcode199, + &x64Parser::Opcode200, + &x64Parser::Opcode201, + &x64Parser::Opcode202, + &x64Parser::Opcode203, + &x64Parser::Opcode204, + &x64Parser::Opcode205, + &x64Parser::Opcode206, + &x64Parser::Opcode207, + &x64Parser::Opcode208, + &x64Parser::Opcode209, + &x64Parser::Opcode210, + &x64Parser::Opcode211, + &x64Parser::Opcode212, + &x64Parser::Opcode213, + &x64Parser::Opcode214, + &x64Parser::Opcode215, + &x64Parser::Opcode216, + &x64Parser::Opcode217, + &x64Parser::Opcode218, + &x64Parser::Opcode219, + &x64Parser::Opcode220, + &x64Parser::Opcode221, + &x64Parser::Opcode222, + &x64Parser::Opcode223, + &x64Parser::Opcode224, + &x64Parser::Opcode225, + &x64Parser::Opcode226, + &x64Parser::Opcode227, + &x64Parser::Opcode228, + &x64Parser::Opcode229, + &x64Parser::Opcode230, + &x64Parser::Opcode231, + &x64Parser::Opcode232, + &x64Parser::Opcode233, + &x64Parser::Opcode234, + &x64Parser::Opcode235, + &x64Parser::Opcode236, + &x64Parser::Opcode237, + &x64Parser::Opcode238, + &x64Parser::Opcode239, + &x64Parser::Opcode240, + &x64Parser::Opcode241, + &x64Parser::Opcode242, + &x64Parser::Opcode243, + &x64Parser::Opcode244, + &x64Parser::Opcode245, + &x64Parser::Opcode246, + &x64Parser::Opcode247, + &x64Parser::Opcode248, + &x64Parser::Opcode249, + &x64Parser::Opcode250, + &x64Parser::Opcode251, + &x64Parser::Opcode252, + &x64Parser::Opcode253, + &x64Parser::Opcode254, + &x64Parser::Opcode255, + &x64Parser::Opcode256, + &x64Parser::Opcode257, + &x64Parser::Opcode258, + &x64Parser::Opcode259, + &x64Parser::Opcode260, + &x64Parser::Opcode261, + &x64Parser::Opcode262, + &x64Parser::Opcode263, + &x64Parser::Opcode264, + &x64Parser::Opcode265, + &x64Parser::Opcode266, + &x64Parser::Opcode267, + &x64Parser::Opcode268, + &x64Parser::Opcode269, + &x64Parser::Opcode270, + &x64Parser::Opcode271, + &x64Parser::Opcode272, + &x64Parser::Opcode273, + &x64Parser::Opcode274, + &x64Parser::Opcode275, + &x64Parser::Opcode276, + &x64Parser::Opcode277, + &x64Parser::Opcode278, + &x64Parser::Opcode279, + &x64Parser::Opcode280, + &x64Parser::Opcode281, + &x64Parser::Opcode282, + &x64Parser::Opcode283, + &x64Parser::Opcode284, + &x64Parser::Opcode285, + &x64Parser::Opcode286, + &x64Parser::Opcode287, + &x64Parser::Opcode288, + &x64Parser::Opcode289, + &x64Parser::Opcode290, + &x64Parser::Opcode291, + &x64Parser::Opcode292, + &x64Parser::Opcode293, + &x64Parser::Opcode294, + &x64Parser::Opcode295, + &x64Parser::Opcode296, + &x64Parser::Opcode297, + &x64Parser::Opcode298, + &x64Parser::Opcode299, + &x64Parser::Opcode300, + &x64Parser::Opcode301, + &x64Parser::Opcode302, + &x64Parser::Opcode303, + &x64Parser::Opcode304, + &x64Parser::Opcode305, + &x64Parser::Opcode306, + &x64Parser::Opcode307, + &x64Parser::Opcode308, + &x64Parser::Opcode309, + &x64Parser::Opcode310, + &x64Parser::Opcode311, + &x64Parser::Opcode312, + &x64Parser::Opcode313, + &x64Parser::Opcode314, + &x64Parser::Opcode315, + &x64Parser::Opcode316, + &x64Parser::Opcode317, + &x64Parser::Opcode318, + &x64Parser::Opcode319, + &x64Parser::Opcode320, + &x64Parser::Opcode321, + &x64Parser::Opcode322, + &x64Parser::Opcode323, + &x64Parser::Opcode324, + &x64Parser::Opcode325, + &x64Parser::Opcode326, + &x64Parser::Opcode327, + &x64Parser::Opcode328, + &x64Parser::Opcode329, + &x64Parser::Opcode330, + &x64Parser::Opcode331, + &x64Parser::Opcode332, + &x64Parser::Opcode333, + &x64Parser::Opcode334, + &x64Parser::Opcode335, + &x64Parser::Opcode336, + &x64Parser::Opcode337, + &x64Parser::Opcode338, + &x64Parser::Opcode339, + &x64Parser::Opcode340, + &x64Parser::Opcode341, + &x64Parser::Opcode342, + &x64Parser::Opcode343, + &x64Parser::Opcode344, + &x64Parser::Opcode345, + &x64Parser::Opcode346, + &x64Parser::Opcode347, + &x64Parser::Opcode348, + &x64Parser::Opcode349, + &x64Parser::Opcode350, + &x64Parser::Opcode351, + &x64Parser::Opcode352, + &x64Parser::Opcode353, + &x64Parser::Opcode354, + &x64Parser::Opcode355, + &x64Parser::Opcode356, + &x64Parser::Opcode357, + &x64Parser::Opcode358, + &x64Parser::Opcode359, + &x64Parser::Opcode360, + &x64Parser::Opcode361, + &x64Parser::Opcode362, + &x64Parser::Opcode363, + &x64Parser::Opcode364, + &x64Parser::Opcode365, + &x64Parser::Opcode366, + &x64Parser::Opcode367, + &x64Parser::Opcode368, + &x64Parser::Opcode369, + &x64Parser::Opcode370, + &x64Parser::Opcode371, + &x64Parser::Opcode372, + &x64Parser::Opcode373, + &x64Parser::Opcode374, + &x64Parser::Opcode375, + &x64Parser::Opcode376, + &x64Parser::Opcode377, + &x64Parser::Opcode378, + &x64Parser::Opcode379, + &x64Parser::Opcode380, + &x64Parser::Opcode381, + &x64Parser::Opcode382, + &x64Parser::Opcode383, + &x64Parser::Opcode384, + &x64Parser::Opcode385, + &x64Parser::Opcode386, + &x64Parser::Opcode387, + &x64Parser::Opcode388, + &x64Parser::Opcode389, + &x64Parser::Opcode390, + &x64Parser::Opcode391, + &x64Parser::Opcode392, + &x64Parser::Opcode393, + &x64Parser::Opcode394, + &x64Parser::Opcode395, + &x64Parser::Opcode396, + &x64Parser::Opcode397, + &x64Parser::Opcode398, + &x64Parser::Opcode399, + &x64Parser::Opcode400, + &x64Parser::Opcode401, + &x64Parser::Opcode402, + &x64Parser::Opcode403, + &x64Parser::Opcode404, + &x64Parser::Opcode405, + &x64Parser::Opcode406, + &x64Parser::Opcode407, + &x64Parser::Opcode408, + &x64Parser::Opcode409, + &x64Parser::Opcode410, + &x64Parser::Opcode411, + &x64Parser::Opcode412, + &x64Parser::Opcode413, + &x64Parser::Opcode414, + &x64Parser::Opcode415, + &x64Parser::Opcode416, + &x64Parser::Opcode417, + &x64Parser::Opcode418, + &x64Parser::Opcode419, + &x64Parser::Opcode420, + &x64Parser::Opcode421, + &x64Parser::Opcode422, + &x64Parser::Opcode423, + &x64Parser::Opcode424, + &x64Parser::Opcode425, + &x64Parser::Opcode426, + &x64Parser::Opcode427, + &x64Parser::Opcode428, + &x64Parser::Opcode429, + &x64Parser::Opcode430, + &x64Parser::Opcode431, + &x64Parser::Opcode432, + &x64Parser::Opcode433, + &x64Parser::Opcode434, + &x64Parser::Opcode435, + &x64Parser::Opcode436, + &x64Parser::Opcode437, + &x64Parser::Opcode438, + &x64Parser::Opcode439, + &x64Parser::Opcode440, + &x64Parser::Opcode441, + &x64Parser::Opcode442, + &x64Parser::Opcode443, + &x64Parser::Opcode444, + &x64Parser::Opcode445, + &x64Parser::Opcode446, + &x64Parser::Opcode447, + &x64Parser::Opcode448, + &x64Parser::Opcode449, + &x64Parser::Opcode450, + &x64Parser::Opcode451, + &x64Parser::Opcode452, + &x64Parser::Opcode453, + &x64Parser::Opcode454, + &x64Parser::Opcode455, + &x64Parser::Opcode456, + &x64Parser::Opcode457, + &x64Parser::Opcode458, + &x64Parser::Opcode459, + &x64Parser::Opcode460, + &x64Parser::Opcode461, + &x64Parser::Opcode462, + &x64Parser::Opcode463, + &x64Parser::Opcode464, + &x64Parser::Opcode465, + &x64Parser::Opcode466, + &x64Parser::Opcode467, + &x64Parser::Opcode468, + &x64Parser::Opcode469, + &x64Parser::Opcode470, + &x64Parser::Opcode471, + &x64Parser::Opcode472, + &x64Parser::Opcode473, + &x64Parser::Opcode474, + &x64Parser::Opcode475, + &x64Parser::Opcode476, + &x64Parser::Opcode477, + &x64Parser::Opcode478, + &x64Parser::Opcode479, + &x64Parser::Opcode480, + &x64Parser::Opcode481, + &x64Parser::Opcode482, + &x64Parser::Opcode483, + &x64Parser::Opcode484, + &x64Parser::Opcode485, + &x64Parser::Opcode486, + &x64Parser::Opcode487, + &x64Parser::Opcode488, + &x64Parser::Opcode489, + &x64Parser::Opcode490, + &x64Parser::Opcode491, + &x64Parser::Opcode492, + &x64Parser::Opcode493, + &x64Parser::Opcode494, + &x64Parser::Opcode495, + &x64Parser::Opcode496, + &x64Parser::Opcode497, + &x64Parser::Opcode498, + &x64Parser::Opcode499, + &x64Parser::Opcode500, + &x64Parser::Opcode501, + &x64Parser::Opcode502, + &x64Parser::Opcode503, + &x64Parser::Opcode504, + &x64Parser::Opcode505, + &x64Parser::Opcode506, + &x64Parser::Opcode507, + &x64Parser::Opcode508, + &x64Parser::Opcode509, + &x64Parser::Opcode510, + &x64Parser::Opcode511, + &x64Parser::Opcode512, + &x64Parser::Opcode513, + &x64Parser::Opcode514, + &x64Parser::Opcode515, + &x64Parser::Opcode516, + &x64Parser::Opcode517, + &x64Parser::Opcode518, + &x64Parser::Opcode519, + &x64Parser::Opcode520, + &x64Parser::Opcode521, + &x64Parser::Opcode522, + &x64Parser::Opcode523, + &x64Parser::Opcode524, + &x64Parser::Opcode525, + &x64Parser::Opcode526, + &x64Parser::Opcode527, + &x64Parser::Opcode528, + &x64Parser::Opcode529, + &x64Parser::Opcode530, + &x64Parser::Opcode531, + &x64Parser::Opcode532, + &x64Parser::Opcode533, + &x64Parser::Opcode534, + &x64Parser::Opcode535, + &x64Parser::Opcode536, + &x64Parser::Opcode537, + &x64Parser::Opcode538, + &x64Parser::Opcode539, + &x64Parser::Opcode540, + &x64Parser::Opcode541, + &x64Parser::Opcode542, + &x64Parser::Opcode543, + &x64Parser::Opcode544, + &x64Parser::Opcode545, + &x64Parser::Opcode546, + &x64Parser::Opcode547, + &x64Parser::Opcode548, + &x64Parser::Opcode549, + &x64Parser::Opcode550, + &x64Parser::Opcode551, + &x64Parser::Opcode552, + &x64Parser::Opcode553, + &x64Parser::Opcode554, + &x64Parser::Opcode555, + &x64Parser::Opcode556, + &x64Parser::Opcode557, + &x64Parser::Opcode558, + &x64Parser::Opcode559, + &x64Parser::Opcode560, + &x64Parser::Opcode561, + &x64Parser::Opcode562, + &x64Parser::Opcode563, + &x64Parser::Opcode564, + &x64Parser::Opcode565, + &x64Parser::Opcode566, + &x64Parser::Opcode567, + &x64Parser::Opcode568, + &x64Parser::Opcode569, + &x64Parser::Opcode570, + &x64Parser::Opcode571, + &x64Parser::Opcode572, + &x64Parser::Opcode573, + &x64Parser::Opcode574, + &x64Parser::Opcode575, + &x64Parser::Opcode576, + &x64Parser::Opcode577, + &x64Parser::Opcode578, + &x64Parser::Opcode579, + &x64Parser::Opcode580, + &x64Parser::Opcode581, + &x64Parser::Opcode582, + &x64Parser::Opcode583, + &x64Parser::Opcode584, + &x64Parser::Opcode585, + &x64Parser::Opcode586, + &x64Parser::Opcode587, + &x64Parser::Opcode588, + &x64Parser::Opcode589, + &x64Parser::Opcode590, + &x64Parser::Opcode591, + &x64Parser::Opcode592, + &x64Parser::Opcode593, + &x64Parser::Opcode594, + &x64Parser::Opcode595, + &x64Parser::Opcode596, + &x64Parser::Opcode597, + &x64Parser::Opcode598, + &x64Parser::Opcode599, + &x64Parser::Opcode600, + &x64Parser::Opcode601, + &x64Parser::Opcode602, + &x64Parser::Opcode603, + &x64Parser::Opcode604, + &x64Parser::Opcode605, + &x64Parser::Opcode606, + &x64Parser::Opcode607, + &x64Parser::Opcode608, + &x64Parser::Opcode609, + &x64Parser::Opcode610, + &x64Parser::Opcode611, + &x64Parser::Opcode612, + &x64Parser::Opcode613, + &x64Parser::Opcode614, + &x64Parser::Opcode615, + &x64Parser::Opcode616, + &x64Parser::Opcode617, + &x64Parser::Opcode618, + &x64Parser::Opcode619, + &x64Parser::Opcode620, }; -x64Token* x64Parser::addressTable[] = { - &x64Parser::tokenBranches3[0], &x64Parser::tokenBranches8[0], &x64Parser::tokenBranches199[0], - &x64Parser::tokenBranches345[0], &x64Parser::tokenBranches198[0], &x64Parser::tokenBranches35[0], - &x64Parser::tokenBranches136[0], &x64Parser::tokenBranches282[0], &x64Parser::tokenBranches428[0], - &x64Parser::tokenBranches34[0], &x64Parser::tokenBranches33[0], &x64Parser::tokenBranches226[0], - &x64Parser::tokenBranches372[0], &x64Parser::tokenBranches225[0], &x64Parser::tokenBranches56[0], - &x64Parser::tokenBranches169[0], &x64Parser::tokenBranches315[0], &x64Parser::tokenBranches461[0], - &x64Parser::tokenBranches55[0], &x64Parser::tokenBranches54[0], &x64Parser::tokenBranches256[0], - &x64Parser::tokenBranches402[0], &x64Parser::tokenBranches255[0], &x64Parser::tokenBranches78[0], - &x64Parser::tokenBranches605[0], &x64Parser::tokenBranches701[0], &x64Parser::tokenBranches825[0], - &x64Parser::tokenBranches2120[0], &x64Parser::tokenBranches2679[0], &x64Parser::tokenBranches2950[0], - &x64Parser::tokenBranches2119[0], &x64Parser::tokenBranches2118[0], &x64Parser::tokenBranches2117[0], - &x64Parser::tokenBranches2129[0], &x64Parser::tokenBranches2688[0], &x64Parser::tokenBranches2959[0], - &x64Parser::tokenBranches2128[0], &x64Parser::tokenBranches2116[0], &x64Parser::tokenBranches604[0], - &x64Parser::tokenBranches505[0], &x64Parser::tokenBranches612[0], &x64Parser::tokenBranches708[0], - &x64Parser::tokenBranches832[0], &x64Parser::tokenBranches2100[0], &x64Parser::tokenBranches2659[0], - &x64Parser::tokenBranches2930[0], &x64Parser::tokenBranches2099[0], &x64Parser::tokenBranches2098[0], - &x64Parser::tokenBranches2097[0], &x64Parser::tokenBranches2109[0], &x64Parser::tokenBranches2668[0], - &x64Parser::tokenBranches2939[0], &x64Parser::tokenBranches2108[0], &x64Parser::tokenBranches2096[0], - &x64Parser::tokenBranches2218[0], &x64Parser::tokenBranches2630[0], &x64Parser::tokenBranches3008[0], - &x64Parser::tokenBranches2217[0], &x64Parser::tokenBranches2216[0], &x64Parser::tokenBranches611[0], - &x64Parser::tokenBranches974[0], &x64Parser::tokenBranches983[0], &x64Parser::tokenBranches992[0], - &x64Parser::tokenBranches973[0], &x64Parser::tokenBranches965[0], &x64Parser::tokenBranches1102[0], - &x64Parser::tokenBranches1111[0], &x64Parser::tokenBranches1120[0], &x64Parser::tokenBranches1101[0], - &x64Parser::tokenBranches1093[0], &x64Parser::tokenBranches1479[0], &x64Parser::tokenBranches1488[0], - &x64Parser::tokenBranches1478[0], &x64Parser::tokenBranches1470[0], &x64Parser::tokenBranches964[0], - &x64Parser::tokenBranches510[0], &x64Parser::tokenBranches652[0], &x64Parser::tokenBranches776[0], - &x64Parser::tokenBranches900[0], &x64Parser::tokenBranches651[0], &x64Parser::tokenBranches537[0], - &x64Parser::tokenBranches643[0], &x64Parser::tokenBranches767[0], &x64Parser::tokenBranches891[0], - &x64Parser::tokenBranches2299[0], &x64Parser::tokenBranches2831[0], &x64Parser::tokenBranches3129[0], - &x64Parser::tokenBranches2298[0], &x64Parser::tokenBranches2297[0], &x64Parser::tokenBranches2296[0], - &x64Parser::tokenBranches2308[0], &x64Parser::tokenBranches2840[0], &x64Parser::tokenBranches3138[0], - &x64Parser::tokenBranches2307[0], &x64Parser::tokenBranches2295[0], &x64Parser::tokenBranches536[0], - &x64Parser::tokenBranches1624[0], &x64Parser::tokenBranches1633[0], &x64Parser::tokenBranches1642[0], - &x64Parser::tokenBranches1623[0], &x64Parser::tokenBranches1615[0], &x64Parser::tokenBranches1752[0], - &x64Parser::tokenBranches1761[0], &x64Parser::tokenBranches1770[0], &x64Parser::tokenBranches1751[0], - &x64Parser::tokenBranches1743[0], &x64Parser::tokenBranches1898[0], &x64Parser::tokenBranches1907[0], - &x64Parser::tokenBranches1927[0], &x64Parser::tokenBranches1938[0], &x64Parser::tokenBranches1926[0], - &x64Parser::tokenBranches1916[0], &x64Parser::tokenBranches1897[0], &x64Parser::tokenBranches1889[0], - &x64Parser::tokenBranches1614[0], &x64Parser::tokenBranches525[0], &x64Parser::tokenBranches564[0], - &x64Parser::tokenBranches1230[0], &x64Parser::tokenBranches1239[0], &x64Parser::tokenBranches1248[0], - &x64Parser::tokenBranches1229[0], &x64Parser::tokenBranches1221[0], &x64Parser::tokenBranches1358[0], - &x64Parser::tokenBranches1367[0], &x64Parser::tokenBranches1376[0], &x64Parser::tokenBranches1357[0], - &x64Parser::tokenBranches1349[0], &x64Parser::tokenBranches1220[0], &x64Parser::tokenBranches1219[0], - &x64Parser::tokenBranches3747[0], &x64Parser::tokenBranches3756[0], &x64Parser::tokenBranches3765[0], - &x64Parser::tokenBranches3746[0], &x64Parser::tokenBranches3738[0], &x64Parser::tokenBranches3875[0], - &x64Parser::tokenBranches3884[0], &x64Parser::tokenBranches3893[0], &x64Parser::tokenBranches3874[0], - &x64Parser::tokenBranches3866[0], &x64Parser::tokenBranches3737[0], &x64Parser::tokenBranches3736[0], - &x64Parser::tokenBranches4003[0], &x64Parser::tokenBranches4012[0], &x64Parser::tokenBranches4021[0], - &x64Parser::tokenBranches4002[0], &x64Parser::tokenBranches3994[0], &x64Parser::tokenBranches4131[0], - &x64Parser::tokenBranches4140[0], &x64Parser::tokenBranches4149[0], &x64Parser::tokenBranches4130[0], - &x64Parser::tokenBranches4122[0], &x64Parser::tokenBranches3993[0], &x64Parser::tokenBranches3992[0], - &x64Parser::tokenBranches7[0], &x64Parser::tokenBranches6[0], &x64Parser::tokenBranches13[0], - &x64Parser::tokenBranches208[0], &x64Parser::tokenBranches354[0], &x64Parser::tokenBranches207[0], - &x64Parser::tokenBranches42[0], &x64Parser::tokenBranches143[0], &x64Parser::tokenBranches289[0], - &x64Parser::tokenBranches435[0], &x64Parser::tokenBranches41[0], &x64Parser::tokenBranches40[0], - &x64Parser::tokenBranches217[0], &x64Parser::tokenBranches363[0], &x64Parser::tokenBranches216[0], - &x64Parser::tokenBranches49[0], &x64Parser::tokenBranches162[0], &x64Parser::tokenBranches308[0], - &x64Parser::tokenBranches454[0], &x64Parser::tokenBranches48[0], &x64Parser::tokenBranches47[0], - &x64Parser::tokenBranches263[0], &x64Parser::tokenBranches409[0], &x64Parser::tokenBranches262[0], - &x64Parser::tokenBranches83[0], &x64Parser::tokenBranches591[0], &x64Parser::tokenBranches715[0], - &x64Parser::tokenBranches839[0], &x64Parser::tokenBranches2160[0], &x64Parser::tokenBranches2719[0], - &x64Parser::tokenBranches2990[0], &x64Parser::tokenBranches2159[0], &x64Parser::tokenBranches2158[0], - &x64Parser::tokenBranches2157[0], &x64Parser::tokenBranches2169[0], &x64Parser::tokenBranches2728[0], - &x64Parser::tokenBranches2999[0], &x64Parser::tokenBranches2168[0], &x64Parser::tokenBranches2156[0], - &x64Parser::tokenBranches590[0], &x64Parser::tokenBranches515[0], &x64Parser::tokenBranches598[0], - &x64Parser::tokenBranches722[0], &x64Parser::tokenBranches846[0], &x64Parser::tokenBranches2140[0], - &x64Parser::tokenBranches2699[0], &x64Parser::tokenBranches2970[0], &x64Parser::tokenBranches2139[0], - &x64Parser::tokenBranches2138[0], &x64Parser::tokenBranches2137[0], &x64Parser::tokenBranches2149[0], - &x64Parser::tokenBranches2708[0], &x64Parser::tokenBranches2979[0], &x64Parser::tokenBranches2148[0], - &x64Parser::tokenBranches2136[0], &x64Parser::tokenBranches2227[0], &x64Parser::tokenBranches2639[0], - &x64Parser::tokenBranches3017[0], &x64Parser::tokenBranches2226[0], &x64Parser::tokenBranches2225[0], - &x64Parser::tokenBranches597[0], &x64Parser::tokenBranches1008[0], &x64Parser::tokenBranches1017[0], - &x64Parser::tokenBranches1026[0], &x64Parser::tokenBranches1007[0], &x64Parser::tokenBranches999[0], - &x64Parser::tokenBranches1136[0], &x64Parser::tokenBranches1145[0], &x64Parser::tokenBranches1154[0], - &x64Parser::tokenBranches1135[0], &x64Parser::tokenBranches1127[0], &x64Parser::tokenBranches1504[0], - &x64Parser::tokenBranches1513[0], &x64Parser::tokenBranches1503[0], &x64Parser::tokenBranches1495[0], - &x64Parser::tokenBranches998[0], &x64Parser::tokenBranches520[0], &x64Parser::tokenBranches668[0], - &x64Parser::tokenBranches792[0], &x64Parser::tokenBranches916[0], &x64Parser::tokenBranches667[0], - &x64Parser::tokenBranches544[0], &x64Parser::tokenBranches659[0], &x64Parser::tokenBranches783[0], - &x64Parser::tokenBranches907[0], &x64Parser::tokenBranches2319[0], &x64Parser::tokenBranches2851[0], - &x64Parser::tokenBranches3149[0], &x64Parser::tokenBranches2318[0], &x64Parser::tokenBranches2317[0], - &x64Parser::tokenBranches2316[0], &x64Parser::tokenBranches2328[0], &x64Parser::tokenBranches2860[0], - &x64Parser::tokenBranches3158[0], &x64Parser::tokenBranches2327[0], &x64Parser::tokenBranches2315[0], - &x64Parser::tokenBranches543[0], &x64Parser::tokenBranches1658[0], &x64Parser::tokenBranches1667[0], - &x64Parser::tokenBranches1676[0], &x64Parser::tokenBranches1657[0], &x64Parser::tokenBranches1649[0], - &x64Parser::tokenBranches1786[0], &x64Parser::tokenBranches1795[0], &x64Parser::tokenBranches1804[0], - &x64Parser::tokenBranches1785[0], &x64Parser::tokenBranches1777[0], &x64Parser::tokenBranches1954[0], - &x64Parser::tokenBranches1963[0], &x64Parser::tokenBranches1983[0], &x64Parser::tokenBranches1994[0], - &x64Parser::tokenBranches1982[0], &x64Parser::tokenBranches1972[0], &x64Parser::tokenBranches1953[0], - &x64Parser::tokenBranches1945[0], &x64Parser::tokenBranches1648[0], &x64Parser::tokenBranches530[0], - &x64Parser::tokenBranches569[0], &x64Parser::tokenBranches1264[0], &x64Parser::tokenBranches1273[0], - &x64Parser::tokenBranches1282[0], &x64Parser::tokenBranches1263[0], &x64Parser::tokenBranches1255[0], - &x64Parser::tokenBranches1392[0], &x64Parser::tokenBranches1401[0], &x64Parser::tokenBranches1410[0], - &x64Parser::tokenBranches1391[0], &x64Parser::tokenBranches1383[0], &x64Parser::tokenBranches1254[0], - &x64Parser::tokenBranches1253[0], &x64Parser::tokenBranches3781[0], &x64Parser::tokenBranches3790[0], - &x64Parser::tokenBranches3799[0], &x64Parser::tokenBranches3780[0], &x64Parser::tokenBranches3772[0], - &x64Parser::tokenBranches3909[0], &x64Parser::tokenBranches3918[0], &x64Parser::tokenBranches3927[0], - &x64Parser::tokenBranches3908[0], &x64Parser::tokenBranches3900[0], &x64Parser::tokenBranches3771[0], - &x64Parser::tokenBranches3770[0], &x64Parser::tokenBranches4037[0], &x64Parser::tokenBranches4046[0], - &x64Parser::tokenBranches4055[0], &x64Parser::tokenBranches4036[0], &x64Parser::tokenBranches4028[0], - &x64Parser::tokenBranches4165[0], &x64Parser::tokenBranches4174[0], &x64Parser::tokenBranches4183[0], - &x64Parser::tokenBranches4164[0], &x64Parser::tokenBranches4156[0], &x64Parser::tokenBranches4027[0], - &x64Parser::tokenBranches4026[0], &x64Parser::tokenBranches12[0], &x64Parser::tokenBranches11[0], - &x64Parser::tokenBranches18[0], &x64Parser::tokenBranches235[0], &x64Parser::tokenBranches381[0], - &x64Parser::tokenBranches234[0], &x64Parser::tokenBranches63[0], &x64Parser::tokenBranches150[0], - &x64Parser::tokenBranches296[0], &x64Parser::tokenBranches442[0], &x64Parser::tokenBranches62[0], - &x64Parser::tokenBranches61[0], &x64Parser::tokenBranches244[0], &x64Parser::tokenBranches390[0], - &x64Parser::tokenBranches243[0], &x64Parser::tokenBranches70[0], &x64Parser::tokenBranches176[0], - &x64Parser::tokenBranches322[0], &x64Parser::tokenBranches468[0], &x64Parser::tokenBranches69[0], - &x64Parser::tokenBranches68[0], &x64Parser::tokenBranches270[0], &x64Parser::tokenBranches416[0], - &x64Parser::tokenBranches269[0], &x64Parser::tokenBranches88[0], &x64Parser::tokenBranches729[0], - &x64Parser::tokenBranches853[0], &x64Parser::tokenBranches2200[0], &x64Parser::tokenBranches2759[0], - &x64Parser::tokenBranches3057[0], &x64Parser::tokenBranches2199[0], &x64Parser::tokenBranches2198[0], - &x64Parser::tokenBranches2197[0], &x64Parser::tokenBranches2209[0], &x64Parser::tokenBranches2768[0], - &x64Parser::tokenBranches3066[0], &x64Parser::tokenBranches2208[0], &x64Parser::tokenBranches2196[0], - &x64Parser::tokenBranches728[0], &x64Parser::tokenBranches490[0], &x64Parser::tokenBranches736[0], - &x64Parser::tokenBranches860[0], &x64Parser::tokenBranches2180[0], &x64Parser::tokenBranches2739[0], - &x64Parser::tokenBranches3037[0], &x64Parser::tokenBranches2179[0], &x64Parser::tokenBranches2178[0], - &x64Parser::tokenBranches2177[0], &x64Parser::tokenBranches2189[0], &x64Parser::tokenBranches2748[0], - &x64Parser::tokenBranches3046[0], &x64Parser::tokenBranches2188[0], &x64Parser::tokenBranches2176[0], - &x64Parser::tokenBranches2236[0], &x64Parser::tokenBranches2648[0], &x64Parser::tokenBranches3026[0], - &x64Parser::tokenBranches2235[0], &x64Parser::tokenBranches2234[0], &x64Parser::tokenBranches735[0], - &x64Parser::tokenBranches1042[0], &x64Parser::tokenBranches1051[0], &x64Parser::tokenBranches1060[0], - &x64Parser::tokenBranches1041[0], &x64Parser::tokenBranches1033[0], &x64Parser::tokenBranches1170[0], - &x64Parser::tokenBranches1179[0], &x64Parser::tokenBranches1188[0], &x64Parser::tokenBranches1169[0], - &x64Parser::tokenBranches1161[0], &x64Parser::tokenBranches1529[0], &x64Parser::tokenBranches1538[0], - &x64Parser::tokenBranches1528[0], &x64Parser::tokenBranches1520[0], &x64Parser::tokenBranches1032[0], - &x64Parser::tokenBranches495[0], &x64Parser::tokenBranches636[0], &x64Parser::tokenBranches760[0], - &x64Parser::tokenBranches884[0], &x64Parser::tokenBranches2279[0], &x64Parser::tokenBranches2811[0], - &x64Parser::tokenBranches3109[0], &x64Parser::tokenBranches2278[0], &x64Parser::tokenBranches2277[0], - &x64Parser::tokenBranches2276[0], &x64Parser::tokenBranches2288[0], &x64Parser::tokenBranches2820[0], - &x64Parser::tokenBranches3118[0], &x64Parser::tokenBranches2287[0], &x64Parser::tokenBranches2275[0], - &x64Parser::tokenBranches635[0], &x64Parser::tokenBranches1298[0], &x64Parser::tokenBranches1307[0], - &x64Parser::tokenBranches1316[0], &x64Parser::tokenBranches1297[0], &x64Parser::tokenBranches1289[0], - &x64Parser::tokenBranches1426[0], &x64Parser::tokenBranches1435[0], &x64Parser::tokenBranches1444[0], - &x64Parser::tokenBranches1425[0], &x64Parser::tokenBranches1417[0], &x64Parser::tokenBranches1573[0], - &x64Parser::tokenBranches1582[0], &x64Parser::tokenBranches1572[0], &x64Parser::tokenBranches1564[0], - &x64Parser::tokenBranches1288[0], &x64Parser::tokenBranches500[0], &x64Parser::tokenBranches684[0], - &x64Parser::tokenBranches808[0], &x64Parser::tokenBranches925[0], &x64Parser::tokenBranches683[0], - &x64Parser::tokenBranches556[0], &x64Parser::tokenBranches675[0], &x64Parser::tokenBranches799[0], - &x64Parser::tokenBranches932[0], &x64Parser::tokenBranches2339[0], &x64Parser::tokenBranches2871[0], - &x64Parser::tokenBranches3169[0], &x64Parser::tokenBranches2338[0], &x64Parser::tokenBranches2337[0], - &x64Parser::tokenBranches2336[0], &x64Parser::tokenBranches2348[0], &x64Parser::tokenBranches2880[0], - &x64Parser::tokenBranches3178[0], &x64Parser::tokenBranches2347[0], &x64Parser::tokenBranches2335[0], - &x64Parser::tokenBranches555[0], &x64Parser::tokenBranches1692[0], &x64Parser::tokenBranches1701[0], - &x64Parser::tokenBranches1710[0], &x64Parser::tokenBranches1691[0], &x64Parser::tokenBranches1683[0], - &x64Parser::tokenBranches1820[0], &x64Parser::tokenBranches1829[0], &x64Parser::tokenBranches1838[0], - &x64Parser::tokenBranches1819[0], &x64Parser::tokenBranches1811[0], &x64Parser::tokenBranches2010[0], - &x64Parser::tokenBranches2019[0], &x64Parser::tokenBranches2039[0], &x64Parser::tokenBranches2050[0], - &x64Parser::tokenBranches2038[0], &x64Parser::tokenBranches2028[0], &x64Parser::tokenBranches2009[0], - &x64Parser::tokenBranches2001[0], &x64Parser::tokenBranches1682[0], &x64Parser::tokenBranches549[0], - &x64Parser::tokenBranches574[0], &x64Parser::tokenBranches3276[0], &x64Parser::tokenBranches3367[0], - &x64Parser::tokenBranches3459[0], &x64Parser::tokenBranches4568[0], &x64Parser::tokenBranches4944[0], - &x64Parser::tokenBranches5156[0], &x64Parser::tokenBranches4567[0], &x64Parser::tokenBranches4566[0], - &x64Parser::tokenBranches4565[0], &x64Parser::tokenBranches4577[0], &x64Parser::tokenBranches4953[0], - &x64Parser::tokenBranches5165[0], &x64Parser::tokenBranches4576[0], &x64Parser::tokenBranches4564[0], - &x64Parser::tokenBranches3275[0], &x64Parser::tokenBranches3195[0], &x64Parser::tokenBranches3336[0], - &x64Parser::tokenBranches3428[0], &x64Parser::tokenBranches3520[0], &x64Parser::tokenBranches3335[0], - &x64Parser::tokenBranches3235[0], &x64Parser::tokenBranches3374[0], &x64Parser::tokenBranches3466[0], - &x64Parser::tokenBranches4588[0], &x64Parser::tokenBranches4964[0], &x64Parser::tokenBranches5176[0], - &x64Parser::tokenBranches4587[0], &x64Parser::tokenBranches4586[0], &x64Parser::tokenBranches4585[0], - &x64Parser::tokenBranches4597[0], &x64Parser::tokenBranches4973[0], &x64Parser::tokenBranches5185[0], - &x64Parser::tokenBranches4596[0], &x64Parser::tokenBranches4584[0], &x64Parser::tokenBranches3234[0], - &x64Parser::tokenBranches3282[0], &x64Parser::tokenBranches3571[0], &x64Parser::tokenBranches3580[0], - &x64Parser::tokenBranches3589[0], &x64Parser::tokenBranches3570[0], &x64Parser::tokenBranches3562[0], - &x64Parser::tokenBranches3631[0], &x64Parser::tokenBranches3640[0], &x64Parser::tokenBranches3649[0], - &x64Parser::tokenBranches3630[0], &x64Parser::tokenBranches3622[0], &x64Parser::tokenBranches3677[0], - &x64Parser::tokenBranches3676[0], &x64Parser::tokenBranches3668[0], &x64Parser::tokenBranches3705[0], - &x64Parser::tokenBranches3704[0], &x64Parser::tokenBranches3696[0], &x64Parser::tokenBranches3561[0], - &x64Parser::tokenBranches3200[0], &x64Parser::tokenBranches3289[0], &x64Parser::tokenBranches3381[0], - &x64Parser::tokenBranches3473[0], &x64Parser::tokenBranches4480[0], &x64Parser::tokenBranches4856[0], - &x64Parser::tokenBranches5068[0], &x64Parser::tokenBranches4479[0], &x64Parser::tokenBranches4478[0], - &x64Parser::tokenBranches4548[0], &x64Parser::tokenBranches4924[0], &x64Parser::tokenBranches5136[0], - &x64Parser::tokenBranches4547[0], &x64Parser::tokenBranches4546[0], &x64Parser::tokenBranches4545[0], - &x64Parser::tokenBranches4557[0], &x64Parser::tokenBranches4933[0], &x64Parser::tokenBranches5145[0], - &x64Parser::tokenBranches4556[0], &x64Parser::tokenBranches4544[0], &x64Parser::tokenBranches3288[0], - &x64Parser::tokenBranches3815[0], &x64Parser::tokenBranches3824[0], &x64Parser::tokenBranches3833[0], - &x64Parser::tokenBranches3814[0], &x64Parser::tokenBranches3806[0], &x64Parser::tokenBranches3943[0], - &x64Parser::tokenBranches3952[0], &x64Parser::tokenBranches3961[0], &x64Parser::tokenBranches3942[0], - &x64Parser::tokenBranches3934[0], &x64Parser::tokenBranches4245[0], &x64Parser::tokenBranches4244[0], - &x64Parser::tokenBranches4236[0], &x64Parser::tokenBranches3805[0], &x64Parser::tokenBranches3205[0], - &x64Parser::tokenBranches3320[0], &x64Parser::tokenBranches3412[0], &x64Parser::tokenBranches3504[0], - &x64Parser::tokenBranches4489[0], &x64Parser::tokenBranches4865[0], &x64Parser::tokenBranches5077[0], - &x64Parser::tokenBranches4488[0], &x64Parser::tokenBranches4487[0], &x64Parser::tokenBranches4640[0], - &x64Parser::tokenBranches5016[0], &x64Parser::tokenBranches5228[0], &x64Parser::tokenBranches4639[0], - &x64Parser::tokenBranches4638[0], &x64Parser::tokenBranches4637[0], &x64Parser::tokenBranches4649[0], - &x64Parser::tokenBranches5025[0], &x64Parser::tokenBranches5237[0], &x64Parser::tokenBranches4648[0], - &x64Parser::tokenBranches4636[0], &x64Parser::tokenBranches3319[0], &x64Parser::tokenBranches4071[0], - &x64Parser::tokenBranches4080[0], &x64Parser::tokenBranches4089[0], &x64Parser::tokenBranches4070[0], - &x64Parser::tokenBranches4062[0], &x64Parser::tokenBranches4199[0], &x64Parser::tokenBranches4208[0], - &x64Parser::tokenBranches4217[0], &x64Parser::tokenBranches4198[0], &x64Parser::tokenBranches4190[0], - &x64Parser::tokenBranches4273[0], &x64Parser::tokenBranches4272[0], &x64Parser::tokenBranches4264[0], - &x64Parser::tokenBranches4061[0], &x64Parser::tokenBranches3210[0], &x64Parser::tokenBranches3345[0], - &x64Parser::tokenBranches3437[0], &x64Parser::tokenBranches3529[0], &x64Parser::tokenBranches3344[0], - &x64Parser::tokenBranches3242[0], &x64Parser::tokenBranches3327[0], &x64Parser::tokenBranches3419[0], - &x64Parser::tokenBranches3511[0], &x64Parser::tokenBranches4660[0], &x64Parser::tokenBranches5036[0], - &x64Parser::tokenBranches5248[0], &x64Parser::tokenBranches4659[0], &x64Parser::tokenBranches4658[0], - &x64Parser::tokenBranches4657[0], &x64Parser::tokenBranches4669[0], &x64Parser::tokenBranches5045[0], - &x64Parser::tokenBranches5257[0], &x64Parser::tokenBranches4668[0], &x64Parser::tokenBranches4656[0], - &x64Parser::tokenBranches3241[0], &x64Parser::tokenBranches4315[0], &x64Parser::tokenBranches4324[0], - &x64Parser::tokenBranches4333[0], &x64Parser::tokenBranches4314[0], &x64Parser::tokenBranches4306[0], - &x64Parser::tokenBranches4375[0], &x64Parser::tokenBranches4384[0], &x64Parser::tokenBranches4393[0], - &x64Parser::tokenBranches4374[0], &x64Parser::tokenBranches4366[0], &x64Parser::tokenBranches4437[0], - &x64Parser::tokenBranches4457[0], &x64Parser::tokenBranches4456[0], &x64Parser::tokenBranches4446[0], - &x64Parser::tokenBranches4436[0], &x64Parser::tokenBranches4428[0], &x64Parser::tokenBranches4305[0], - &x64Parser::tokenBranches3228[0], &x64Parser::tokenBranches3255[0], &x64Parser::tokenBranches17[0], - &x64Parser::tokenBranches16[0], &x64Parser::tokenBranches183[0], &x64Parser::tokenBranches329[0], - &x64Parser::tokenBranches182[0], &x64Parser::tokenBranches23[0], &x64Parser::tokenBranches129[0], - &x64Parser::tokenBranches275[0], &x64Parser::tokenBranches421[0], &x64Parser::tokenBranches22[0], - &x64Parser::tokenBranches21[0], &x64Parser::tokenBranches190[0], &x64Parser::tokenBranches336[0], - &x64Parser::tokenBranches189[0], &x64Parser::tokenBranches28[0], &x64Parser::tokenBranches155[0], - &x64Parser::tokenBranches301[0], &x64Parser::tokenBranches447[0], &x64Parser::tokenBranches27[0], - &x64Parser::tokenBranches26[0], &x64Parser::tokenBranches249[0], &x64Parser::tokenBranches395[0], - &x64Parser::tokenBranches248[0], &x64Parser::tokenBranches73[0], &x64Parser::tokenBranches579[0], - &x64Parser::tokenBranches689[0], &x64Parser::tokenBranches813[0], &x64Parser::tokenBranches2082[0], - &x64Parser::tokenBranches2614[0], &x64Parser::tokenBranches2912[0], &x64Parser::tokenBranches2081[0], - &x64Parser::tokenBranches2080[0], &x64Parser::tokenBranches2079[0], &x64Parser::tokenBranches2089[0], - &x64Parser::tokenBranches2621[0], &x64Parser::tokenBranches2919[0], &x64Parser::tokenBranches2088[0], - &x64Parser::tokenBranches2078[0], &x64Parser::tokenBranches578[0], &x64Parser::tokenBranches471[0], - &x64Parser::tokenBranches584[0], &x64Parser::tokenBranches694[0], &x64Parser::tokenBranches818[0], - &x64Parser::tokenBranches2057[0], &x64Parser::tokenBranches2589[0], &x64Parser::tokenBranches2887[0], - &x64Parser::tokenBranches2056[0], &x64Parser::tokenBranches2055[0], &x64Parser::tokenBranches2066[0], - &x64Parser::tokenBranches2598[0], &x64Parser::tokenBranches2896[0], &x64Parser::tokenBranches2065[0], - &x64Parser::tokenBranches2064[0], &x64Parser::tokenBranches2063[0], &x64Parser::tokenBranches2073[0], - &x64Parser::tokenBranches2605[0], &x64Parser::tokenBranches2903[0], &x64Parser::tokenBranches2072[0], - &x64Parser::tokenBranches2062[0], &x64Parser::tokenBranches583[0], &x64Parser::tokenBranches944[0], - &x64Parser::tokenBranches951[0], &x64Parser::tokenBranches958[0], &x64Parser::tokenBranches943[0], - &x64Parser::tokenBranches937[0], &x64Parser::tokenBranches1072[0], &x64Parser::tokenBranches1079[0], - &x64Parser::tokenBranches1086[0], &x64Parser::tokenBranches1071[0], &x64Parser::tokenBranches1065[0], - &x64Parser::tokenBranches1456[0], &x64Parser::tokenBranches1463[0], &x64Parser::tokenBranches1455[0], - &x64Parser::tokenBranches1449[0], &x64Parser::tokenBranches936[0], &x64Parser::tokenBranches474[0], - &x64Parser::tokenBranches617[0], &x64Parser::tokenBranches741[0], &x64Parser::tokenBranches865[0], - &x64Parser::tokenBranches2245[0], &x64Parser::tokenBranches2777[0], &x64Parser::tokenBranches3075[0], - &x64Parser::tokenBranches2244[0], &x64Parser::tokenBranches2243[0], &x64Parser::tokenBranches2242[0], - &x64Parser::tokenBranches2252[0], &x64Parser::tokenBranches2784[0], &x64Parser::tokenBranches3082[0], - &x64Parser::tokenBranches2251[0], &x64Parser::tokenBranches2241[0], &x64Parser::tokenBranches616[0], - &x64Parser::tokenBranches1200[0], &x64Parser::tokenBranches1207[0], &x64Parser::tokenBranches1214[0], - &x64Parser::tokenBranches1199[0], &x64Parser::tokenBranches1193[0], &x64Parser::tokenBranches1328[0], - &x64Parser::tokenBranches1335[0], &x64Parser::tokenBranches1342[0], &x64Parser::tokenBranches1327[0], - &x64Parser::tokenBranches1321[0], &x64Parser::tokenBranches1550[0], &x64Parser::tokenBranches1557[0], - &x64Parser::tokenBranches1549[0], &x64Parser::tokenBranches1543[0], &x64Parser::tokenBranches1192[0], - &x64Parser::tokenBranches477[0], &x64Parser::tokenBranches629[0], &x64Parser::tokenBranches753[0], - &x64Parser::tokenBranches877[0], &x64Parser::tokenBranches628[0], &x64Parser::tokenBranches485[0], - &x64Parser::tokenBranches622[0], &x64Parser::tokenBranches746[0], &x64Parser::tokenBranches870[0], - &x64Parser::tokenBranches2261[0], &x64Parser::tokenBranches2793[0], &x64Parser::tokenBranches3091[0], - &x64Parser::tokenBranches2260[0], &x64Parser::tokenBranches2259[0], &x64Parser::tokenBranches2258[0], - &x64Parser::tokenBranches2268[0], &x64Parser::tokenBranches2800[0], &x64Parser::tokenBranches3098[0], - &x64Parser::tokenBranches2267[0], &x64Parser::tokenBranches2257[0], &x64Parser::tokenBranches484[0], - &x64Parser::tokenBranches1594[0], &x64Parser::tokenBranches1601[0], &x64Parser::tokenBranches1608[0], - &x64Parser::tokenBranches1593[0], &x64Parser::tokenBranches1587[0], &x64Parser::tokenBranches1722[0], - &x64Parser::tokenBranches1729[0], &x64Parser::tokenBranches1736[0], &x64Parser::tokenBranches1721[0], - &x64Parser::tokenBranches1715[0], &x64Parser::tokenBranches1850[0], &x64Parser::tokenBranches1857[0], - &x64Parser::tokenBranches1873[0], &x64Parser::tokenBranches1882[0], &x64Parser::tokenBranches1872[0], - &x64Parser::tokenBranches1864[0], &x64Parser::tokenBranches1849[0], &x64Parser::tokenBranches1843[0], - &x64Parser::tokenBranches1586[0], &x64Parser::tokenBranches480[0], &x64Parser::tokenBranches559[0], - &x64Parser::tokenBranches3260[0], &x64Parser::tokenBranches3350[0], &x64Parser::tokenBranches3442[0], - &x64Parser::tokenBranches4514[0], &x64Parser::tokenBranches4890[0], &x64Parser::tokenBranches5102[0], - &x64Parser::tokenBranches4513[0], &x64Parser::tokenBranches4512[0], &x64Parser::tokenBranches4511[0], - &x64Parser::tokenBranches4521[0], &x64Parser::tokenBranches4897[0], &x64Parser::tokenBranches5109[0], - &x64Parser::tokenBranches4520[0], &x64Parser::tokenBranches4510[0], &x64Parser::tokenBranches3259[0], - &x64Parser::tokenBranches3181[0], &x64Parser::tokenBranches3306[0], &x64Parser::tokenBranches3398[0], - &x64Parser::tokenBranches3490[0], &x64Parser::tokenBranches3305[0], &x64Parser::tokenBranches3218[0], - &x64Parser::tokenBranches3355[0], &x64Parser::tokenBranches3447[0], &x64Parser::tokenBranches4530[0], - &x64Parser::tokenBranches4906[0], &x64Parser::tokenBranches5118[0], &x64Parser::tokenBranches4529[0], - &x64Parser::tokenBranches4528[0], &x64Parser::tokenBranches4527[0], &x64Parser::tokenBranches4537[0], - &x64Parser::tokenBranches4913[0], &x64Parser::tokenBranches5125[0], &x64Parser::tokenBranches4536[0], - &x64Parser::tokenBranches4526[0], &x64Parser::tokenBranches3217[0], &x64Parser::tokenBranches3264[0], - &x64Parser::tokenBranches3541[0], &x64Parser::tokenBranches3548[0], &x64Parser::tokenBranches3555[0], - &x64Parser::tokenBranches3540[0], &x64Parser::tokenBranches3534[0], &x64Parser::tokenBranches3601[0], - &x64Parser::tokenBranches3608[0], &x64Parser::tokenBranches3615[0], &x64Parser::tokenBranches3600[0], - &x64Parser::tokenBranches3594[0], &x64Parser::tokenBranches3661[0], &x64Parser::tokenBranches3660[0], - &x64Parser::tokenBranches3654[0], &x64Parser::tokenBranches3689[0], &x64Parser::tokenBranches3688[0], - &x64Parser::tokenBranches3682[0], &x64Parser::tokenBranches3533[0], &x64Parser::tokenBranches3184[0], - &x64Parser::tokenBranches3269[0], &x64Parser::tokenBranches3360[0], &x64Parser::tokenBranches3452[0], - &x64Parser::tokenBranches4464[0], &x64Parser::tokenBranches4840[0], &x64Parser::tokenBranches5052[0], - &x64Parser::tokenBranches4463[0], &x64Parser::tokenBranches4462[0], &x64Parser::tokenBranches4498[0], - &x64Parser::tokenBranches4874[0], &x64Parser::tokenBranches5086[0], &x64Parser::tokenBranches4497[0], - &x64Parser::tokenBranches4496[0], &x64Parser::tokenBranches4495[0], &x64Parser::tokenBranches4505[0], - &x64Parser::tokenBranches4881[0], &x64Parser::tokenBranches5093[0], &x64Parser::tokenBranches4504[0], - &x64Parser::tokenBranches4494[0], &x64Parser::tokenBranches3268[0], &x64Parser::tokenBranches3717[0], - &x64Parser::tokenBranches3724[0], &x64Parser::tokenBranches3731[0], &x64Parser::tokenBranches3716[0], - &x64Parser::tokenBranches3710[0], &x64Parser::tokenBranches3845[0], &x64Parser::tokenBranches3852[0], - &x64Parser::tokenBranches3859[0], &x64Parser::tokenBranches3844[0], &x64Parser::tokenBranches3838[0], - &x64Parser::tokenBranches4229[0], &x64Parser::tokenBranches4228[0], &x64Parser::tokenBranches4222[0], - &x64Parser::tokenBranches3709[0], &x64Parser::tokenBranches3187[0], &x64Parser::tokenBranches3294[0], - &x64Parser::tokenBranches3386[0], &x64Parser::tokenBranches3478[0], &x64Parser::tokenBranches4471[0], - &x64Parser::tokenBranches4847[0], &x64Parser::tokenBranches5059[0], &x64Parser::tokenBranches4470[0], - &x64Parser::tokenBranches4469[0], &x64Parser::tokenBranches4606[0], &x64Parser::tokenBranches4982[0], - &x64Parser::tokenBranches5194[0], &x64Parser::tokenBranches4605[0], &x64Parser::tokenBranches4604[0], - &x64Parser::tokenBranches4603[0], &x64Parser::tokenBranches4613[0], &x64Parser::tokenBranches4989[0], - &x64Parser::tokenBranches5201[0], &x64Parser::tokenBranches4612[0], &x64Parser::tokenBranches4602[0], - &x64Parser::tokenBranches3293[0], &x64Parser::tokenBranches3973[0], &x64Parser::tokenBranches3980[0], - &x64Parser::tokenBranches3987[0], &x64Parser::tokenBranches3972[0], &x64Parser::tokenBranches3966[0], - &x64Parser::tokenBranches4101[0], &x64Parser::tokenBranches4108[0], &x64Parser::tokenBranches4115[0], - &x64Parser::tokenBranches4100[0], &x64Parser::tokenBranches4094[0], &x64Parser::tokenBranches4257[0], - &x64Parser::tokenBranches4256[0], &x64Parser::tokenBranches4250[0], &x64Parser::tokenBranches3965[0], - &x64Parser::tokenBranches3190[0], &x64Parser::tokenBranches3313[0], &x64Parser::tokenBranches3405[0], - &x64Parser::tokenBranches3497[0], &x64Parser::tokenBranches3312[0], &x64Parser::tokenBranches3223[0], - &x64Parser::tokenBranches3299[0], &x64Parser::tokenBranches3391[0], &x64Parser::tokenBranches3483[0], - &x64Parser::tokenBranches4622[0], &x64Parser::tokenBranches4998[0], &x64Parser::tokenBranches5210[0], - &x64Parser::tokenBranches4621[0], &x64Parser::tokenBranches4620[0], &x64Parser::tokenBranches4619[0], - &x64Parser::tokenBranches4629[0], &x64Parser::tokenBranches5005[0], &x64Parser::tokenBranches5217[0], - &x64Parser::tokenBranches4628[0], &x64Parser::tokenBranches4618[0], &x64Parser::tokenBranches3222[0], - &x64Parser::tokenBranches4285[0], &x64Parser::tokenBranches4292[0], &x64Parser::tokenBranches4299[0], - &x64Parser::tokenBranches4284[0], &x64Parser::tokenBranches4278[0], &x64Parser::tokenBranches4345[0], - &x64Parser::tokenBranches4352[0], &x64Parser::tokenBranches4359[0], &x64Parser::tokenBranches4344[0], - &x64Parser::tokenBranches4338[0], &x64Parser::tokenBranches4405[0], &x64Parser::tokenBranches4421[0], - &x64Parser::tokenBranches4420[0], &x64Parser::tokenBranches4412[0], &x64Parser::tokenBranches4404[0], - &x64Parser::tokenBranches4398[0], &x64Parser::tokenBranches4277[0], &x64Parser::tokenBranches3213[0], - &x64Parser::tokenBranches3247[0], &x64Parser::tokenBranches3246[0], &x64Parser::tokenBranches3245[0], - &x64Parser::tokenBranches3250[0], &x64Parser::tokenBranches2[0], &x64Parser::tokenBranches1[0], +x64Token *x64Parser::addressTable[] = { + &x64Parser::tokenBranches3[0], + &x64Parser::tokenBranches8[0], + &x64Parser::tokenBranches199[0], + &x64Parser::tokenBranches345[0], + &x64Parser::tokenBranches198[0], + &x64Parser::tokenBranches35[0], + &x64Parser::tokenBranches136[0], + &x64Parser::tokenBranches282[0], + &x64Parser::tokenBranches428[0], + &x64Parser::tokenBranches34[0], + &x64Parser::tokenBranches33[0], + &x64Parser::tokenBranches226[0], + &x64Parser::tokenBranches372[0], + &x64Parser::tokenBranches225[0], + &x64Parser::tokenBranches56[0], + &x64Parser::tokenBranches169[0], + &x64Parser::tokenBranches315[0], + &x64Parser::tokenBranches461[0], + &x64Parser::tokenBranches55[0], + &x64Parser::tokenBranches54[0], + &x64Parser::tokenBranches256[0], + &x64Parser::tokenBranches402[0], + &x64Parser::tokenBranches255[0], + &x64Parser::tokenBranches78[0], + &x64Parser::tokenBranches605[0], + &x64Parser::tokenBranches701[0], + &x64Parser::tokenBranches825[0], + &x64Parser::tokenBranches2120[0], + &x64Parser::tokenBranches2679[0], + &x64Parser::tokenBranches2950[0], + &x64Parser::tokenBranches2119[0], + &x64Parser::tokenBranches2118[0], + &x64Parser::tokenBranches2117[0], + &x64Parser::tokenBranches2129[0], + &x64Parser::tokenBranches2688[0], + &x64Parser::tokenBranches2959[0], + &x64Parser::tokenBranches2128[0], + &x64Parser::tokenBranches2116[0], + &x64Parser::tokenBranches604[0], + &x64Parser::tokenBranches505[0], + &x64Parser::tokenBranches612[0], + &x64Parser::tokenBranches708[0], + &x64Parser::tokenBranches832[0], + &x64Parser::tokenBranches2100[0], + &x64Parser::tokenBranches2659[0], + &x64Parser::tokenBranches2930[0], + &x64Parser::tokenBranches2099[0], + &x64Parser::tokenBranches2098[0], + &x64Parser::tokenBranches2097[0], + &x64Parser::tokenBranches2109[0], + &x64Parser::tokenBranches2668[0], + &x64Parser::tokenBranches2939[0], + &x64Parser::tokenBranches2108[0], + &x64Parser::tokenBranches2096[0], + &x64Parser::tokenBranches2218[0], + &x64Parser::tokenBranches2630[0], + &x64Parser::tokenBranches3008[0], + &x64Parser::tokenBranches2217[0], + &x64Parser::tokenBranches2216[0], + &x64Parser::tokenBranches611[0], + &x64Parser::tokenBranches974[0], + &x64Parser::tokenBranches983[0], + &x64Parser::tokenBranches992[0], + &x64Parser::tokenBranches973[0], + &x64Parser::tokenBranches965[0], + &x64Parser::tokenBranches1102[0], + &x64Parser::tokenBranches1111[0], + &x64Parser::tokenBranches1120[0], + &x64Parser::tokenBranches1101[0], + &x64Parser::tokenBranches1093[0], + &x64Parser::tokenBranches1479[0], + &x64Parser::tokenBranches1488[0], + &x64Parser::tokenBranches1478[0], + &x64Parser::tokenBranches1470[0], + &x64Parser::tokenBranches964[0], + &x64Parser::tokenBranches510[0], + &x64Parser::tokenBranches652[0], + &x64Parser::tokenBranches776[0], + &x64Parser::tokenBranches900[0], + &x64Parser::tokenBranches651[0], + &x64Parser::tokenBranches537[0], + &x64Parser::tokenBranches643[0], + &x64Parser::tokenBranches767[0], + &x64Parser::tokenBranches891[0], + &x64Parser::tokenBranches2299[0], + &x64Parser::tokenBranches2831[0], + &x64Parser::tokenBranches3129[0], + &x64Parser::tokenBranches2298[0], + &x64Parser::tokenBranches2297[0], + &x64Parser::tokenBranches2296[0], + &x64Parser::tokenBranches2308[0], + &x64Parser::tokenBranches2840[0], + &x64Parser::tokenBranches3138[0], + &x64Parser::tokenBranches2307[0], + &x64Parser::tokenBranches2295[0], + &x64Parser::tokenBranches536[0], + &x64Parser::tokenBranches1624[0], + &x64Parser::tokenBranches1633[0], + &x64Parser::tokenBranches1642[0], + &x64Parser::tokenBranches1623[0], + &x64Parser::tokenBranches1615[0], + &x64Parser::tokenBranches1752[0], + &x64Parser::tokenBranches1761[0], + &x64Parser::tokenBranches1770[0], + &x64Parser::tokenBranches1751[0], + &x64Parser::tokenBranches1743[0], + &x64Parser::tokenBranches1898[0], + &x64Parser::tokenBranches1907[0], + &x64Parser::tokenBranches1927[0], + &x64Parser::tokenBranches1938[0], + &x64Parser::tokenBranches1926[0], + &x64Parser::tokenBranches1916[0], + &x64Parser::tokenBranches1897[0], + &x64Parser::tokenBranches1889[0], + &x64Parser::tokenBranches1614[0], + &x64Parser::tokenBranches525[0], + &x64Parser::tokenBranches564[0], + &x64Parser::tokenBranches1230[0], + &x64Parser::tokenBranches1239[0], + &x64Parser::tokenBranches1248[0], + &x64Parser::tokenBranches1229[0], + &x64Parser::tokenBranches1221[0], + &x64Parser::tokenBranches1358[0], + &x64Parser::tokenBranches1367[0], + &x64Parser::tokenBranches1376[0], + &x64Parser::tokenBranches1357[0], + &x64Parser::tokenBranches1349[0], + &x64Parser::tokenBranches1220[0], + &x64Parser::tokenBranches1219[0], + &x64Parser::tokenBranches3747[0], + &x64Parser::tokenBranches3756[0], + &x64Parser::tokenBranches3765[0], + &x64Parser::tokenBranches3746[0], + &x64Parser::tokenBranches3738[0], + &x64Parser::tokenBranches3875[0], + &x64Parser::tokenBranches3884[0], + &x64Parser::tokenBranches3893[0], + &x64Parser::tokenBranches3874[0], + &x64Parser::tokenBranches3866[0], + &x64Parser::tokenBranches3737[0], + &x64Parser::tokenBranches3736[0], + &x64Parser::tokenBranches4003[0], + &x64Parser::tokenBranches4012[0], + &x64Parser::tokenBranches4021[0], + &x64Parser::tokenBranches4002[0], + &x64Parser::tokenBranches3994[0], + &x64Parser::tokenBranches4131[0], + &x64Parser::tokenBranches4140[0], + &x64Parser::tokenBranches4149[0], + &x64Parser::tokenBranches4130[0], + &x64Parser::tokenBranches4122[0], + &x64Parser::tokenBranches3993[0], + &x64Parser::tokenBranches3992[0], + &x64Parser::tokenBranches7[0], + &x64Parser::tokenBranches6[0], + &x64Parser::tokenBranches13[0], + &x64Parser::tokenBranches208[0], + &x64Parser::tokenBranches354[0], + &x64Parser::tokenBranches207[0], + &x64Parser::tokenBranches42[0], + &x64Parser::tokenBranches143[0], + &x64Parser::tokenBranches289[0], + &x64Parser::tokenBranches435[0], + &x64Parser::tokenBranches41[0], + &x64Parser::tokenBranches40[0], + &x64Parser::tokenBranches217[0], + &x64Parser::tokenBranches363[0], + &x64Parser::tokenBranches216[0], + &x64Parser::tokenBranches49[0], + &x64Parser::tokenBranches162[0], + &x64Parser::tokenBranches308[0], + &x64Parser::tokenBranches454[0], + &x64Parser::tokenBranches48[0], + &x64Parser::tokenBranches47[0], + &x64Parser::tokenBranches263[0], + &x64Parser::tokenBranches409[0], + &x64Parser::tokenBranches262[0], + &x64Parser::tokenBranches83[0], + &x64Parser::tokenBranches591[0], + &x64Parser::tokenBranches715[0], + &x64Parser::tokenBranches839[0], + &x64Parser::tokenBranches2160[0], + &x64Parser::tokenBranches2719[0], + &x64Parser::tokenBranches2990[0], + &x64Parser::tokenBranches2159[0], + &x64Parser::tokenBranches2158[0], + &x64Parser::tokenBranches2157[0], + &x64Parser::tokenBranches2169[0], + &x64Parser::tokenBranches2728[0], + &x64Parser::tokenBranches2999[0], + &x64Parser::tokenBranches2168[0], + &x64Parser::tokenBranches2156[0], + &x64Parser::tokenBranches590[0], + &x64Parser::tokenBranches515[0], + &x64Parser::tokenBranches598[0], + &x64Parser::tokenBranches722[0], + &x64Parser::tokenBranches846[0], + &x64Parser::tokenBranches2140[0], + &x64Parser::tokenBranches2699[0], + &x64Parser::tokenBranches2970[0], + &x64Parser::tokenBranches2139[0], + &x64Parser::tokenBranches2138[0], + &x64Parser::tokenBranches2137[0], + &x64Parser::tokenBranches2149[0], + &x64Parser::tokenBranches2708[0], + &x64Parser::tokenBranches2979[0], + &x64Parser::tokenBranches2148[0], + &x64Parser::tokenBranches2136[0], + &x64Parser::tokenBranches2227[0], + &x64Parser::tokenBranches2639[0], + &x64Parser::tokenBranches3017[0], + &x64Parser::tokenBranches2226[0], + &x64Parser::tokenBranches2225[0], + &x64Parser::tokenBranches597[0], + &x64Parser::tokenBranches1008[0], + &x64Parser::tokenBranches1017[0], + &x64Parser::tokenBranches1026[0], + &x64Parser::tokenBranches1007[0], + &x64Parser::tokenBranches999[0], + &x64Parser::tokenBranches1136[0], + &x64Parser::tokenBranches1145[0], + &x64Parser::tokenBranches1154[0], + &x64Parser::tokenBranches1135[0], + &x64Parser::tokenBranches1127[0], + &x64Parser::tokenBranches1504[0], + &x64Parser::tokenBranches1513[0], + &x64Parser::tokenBranches1503[0], + &x64Parser::tokenBranches1495[0], + &x64Parser::tokenBranches998[0], + &x64Parser::tokenBranches520[0], + &x64Parser::tokenBranches668[0], + &x64Parser::tokenBranches792[0], + &x64Parser::tokenBranches916[0], + &x64Parser::tokenBranches667[0], + &x64Parser::tokenBranches544[0], + &x64Parser::tokenBranches659[0], + &x64Parser::tokenBranches783[0], + &x64Parser::tokenBranches907[0], + &x64Parser::tokenBranches2319[0], + &x64Parser::tokenBranches2851[0], + &x64Parser::tokenBranches3149[0], + &x64Parser::tokenBranches2318[0], + &x64Parser::tokenBranches2317[0], + &x64Parser::tokenBranches2316[0], + &x64Parser::tokenBranches2328[0], + &x64Parser::tokenBranches2860[0], + &x64Parser::tokenBranches3158[0], + &x64Parser::tokenBranches2327[0], + &x64Parser::tokenBranches2315[0], + &x64Parser::tokenBranches543[0], + &x64Parser::tokenBranches1658[0], + &x64Parser::tokenBranches1667[0], + &x64Parser::tokenBranches1676[0], + &x64Parser::tokenBranches1657[0], + &x64Parser::tokenBranches1649[0], + &x64Parser::tokenBranches1786[0], + &x64Parser::tokenBranches1795[0], + &x64Parser::tokenBranches1804[0], + &x64Parser::tokenBranches1785[0], + &x64Parser::tokenBranches1777[0], + &x64Parser::tokenBranches1954[0], + &x64Parser::tokenBranches1963[0], + &x64Parser::tokenBranches1983[0], + &x64Parser::tokenBranches1994[0], + &x64Parser::tokenBranches1982[0], + &x64Parser::tokenBranches1972[0], + &x64Parser::tokenBranches1953[0], + &x64Parser::tokenBranches1945[0], + &x64Parser::tokenBranches1648[0], + &x64Parser::tokenBranches530[0], + &x64Parser::tokenBranches569[0], + &x64Parser::tokenBranches1264[0], + &x64Parser::tokenBranches1273[0], + &x64Parser::tokenBranches1282[0], + &x64Parser::tokenBranches1263[0], + &x64Parser::tokenBranches1255[0], + &x64Parser::tokenBranches1392[0], + &x64Parser::tokenBranches1401[0], + &x64Parser::tokenBranches1410[0], + &x64Parser::tokenBranches1391[0], + &x64Parser::tokenBranches1383[0], + &x64Parser::tokenBranches1254[0], + &x64Parser::tokenBranches1253[0], + &x64Parser::tokenBranches3781[0], + &x64Parser::tokenBranches3790[0], + &x64Parser::tokenBranches3799[0], + &x64Parser::tokenBranches3780[0], + &x64Parser::tokenBranches3772[0], + &x64Parser::tokenBranches3909[0], + &x64Parser::tokenBranches3918[0], + &x64Parser::tokenBranches3927[0], + &x64Parser::tokenBranches3908[0], + &x64Parser::tokenBranches3900[0], + &x64Parser::tokenBranches3771[0], + &x64Parser::tokenBranches3770[0], + &x64Parser::tokenBranches4037[0], + &x64Parser::tokenBranches4046[0], + &x64Parser::tokenBranches4055[0], + &x64Parser::tokenBranches4036[0], + &x64Parser::tokenBranches4028[0], + &x64Parser::tokenBranches4165[0], + &x64Parser::tokenBranches4174[0], + &x64Parser::tokenBranches4183[0], + &x64Parser::tokenBranches4164[0], + &x64Parser::tokenBranches4156[0], + &x64Parser::tokenBranches4027[0], + &x64Parser::tokenBranches4026[0], + &x64Parser::tokenBranches12[0], + &x64Parser::tokenBranches11[0], + &x64Parser::tokenBranches18[0], + &x64Parser::tokenBranches235[0], + &x64Parser::tokenBranches381[0], + &x64Parser::tokenBranches234[0], + &x64Parser::tokenBranches63[0], + &x64Parser::tokenBranches150[0], + &x64Parser::tokenBranches296[0], + &x64Parser::tokenBranches442[0], + &x64Parser::tokenBranches62[0], + &x64Parser::tokenBranches61[0], + &x64Parser::tokenBranches244[0], + &x64Parser::tokenBranches390[0], + &x64Parser::tokenBranches243[0], + &x64Parser::tokenBranches70[0], + &x64Parser::tokenBranches176[0], + &x64Parser::tokenBranches322[0], + &x64Parser::tokenBranches468[0], + &x64Parser::tokenBranches69[0], + &x64Parser::tokenBranches68[0], + &x64Parser::tokenBranches270[0], + &x64Parser::tokenBranches416[0], + &x64Parser::tokenBranches269[0], + &x64Parser::tokenBranches88[0], + &x64Parser::tokenBranches729[0], + &x64Parser::tokenBranches853[0], + &x64Parser::tokenBranches2200[0], + &x64Parser::tokenBranches2759[0], + &x64Parser::tokenBranches3057[0], + &x64Parser::tokenBranches2199[0], + &x64Parser::tokenBranches2198[0], + &x64Parser::tokenBranches2197[0], + &x64Parser::tokenBranches2209[0], + &x64Parser::tokenBranches2768[0], + &x64Parser::tokenBranches3066[0], + &x64Parser::tokenBranches2208[0], + &x64Parser::tokenBranches2196[0], + &x64Parser::tokenBranches728[0], + &x64Parser::tokenBranches490[0], + &x64Parser::tokenBranches736[0], + &x64Parser::tokenBranches860[0], + &x64Parser::tokenBranches2180[0], + &x64Parser::tokenBranches2739[0], + &x64Parser::tokenBranches3037[0], + &x64Parser::tokenBranches2179[0], + &x64Parser::tokenBranches2178[0], + &x64Parser::tokenBranches2177[0], + &x64Parser::tokenBranches2189[0], + &x64Parser::tokenBranches2748[0], + &x64Parser::tokenBranches3046[0], + &x64Parser::tokenBranches2188[0], + &x64Parser::tokenBranches2176[0], + &x64Parser::tokenBranches2236[0], + &x64Parser::tokenBranches2648[0], + &x64Parser::tokenBranches3026[0], + &x64Parser::tokenBranches2235[0], + &x64Parser::tokenBranches2234[0], + &x64Parser::tokenBranches735[0], + &x64Parser::tokenBranches1042[0], + &x64Parser::tokenBranches1051[0], + &x64Parser::tokenBranches1060[0], + &x64Parser::tokenBranches1041[0], + &x64Parser::tokenBranches1033[0], + &x64Parser::tokenBranches1170[0], + &x64Parser::tokenBranches1179[0], + &x64Parser::tokenBranches1188[0], + &x64Parser::tokenBranches1169[0], + &x64Parser::tokenBranches1161[0], + &x64Parser::tokenBranches1529[0], + &x64Parser::tokenBranches1538[0], + &x64Parser::tokenBranches1528[0], + &x64Parser::tokenBranches1520[0], + &x64Parser::tokenBranches1032[0], + &x64Parser::tokenBranches495[0], + &x64Parser::tokenBranches636[0], + &x64Parser::tokenBranches760[0], + &x64Parser::tokenBranches884[0], + &x64Parser::tokenBranches2279[0], + &x64Parser::tokenBranches2811[0], + &x64Parser::tokenBranches3109[0], + &x64Parser::tokenBranches2278[0], + &x64Parser::tokenBranches2277[0], + &x64Parser::tokenBranches2276[0], + &x64Parser::tokenBranches2288[0], + &x64Parser::tokenBranches2820[0], + &x64Parser::tokenBranches3118[0], + &x64Parser::tokenBranches2287[0], + &x64Parser::tokenBranches2275[0], + &x64Parser::tokenBranches635[0], + &x64Parser::tokenBranches1298[0], + &x64Parser::tokenBranches1307[0], + &x64Parser::tokenBranches1316[0], + &x64Parser::tokenBranches1297[0], + &x64Parser::tokenBranches1289[0], + &x64Parser::tokenBranches1426[0], + &x64Parser::tokenBranches1435[0], + &x64Parser::tokenBranches1444[0], + &x64Parser::tokenBranches1425[0], + &x64Parser::tokenBranches1417[0], + &x64Parser::tokenBranches1573[0], + &x64Parser::tokenBranches1582[0], + &x64Parser::tokenBranches1572[0], + &x64Parser::tokenBranches1564[0], + &x64Parser::tokenBranches1288[0], + &x64Parser::tokenBranches500[0], + &x64Parser::tokenBranches684[0], + &x64Parser::tokenBranches808[0], + &x64Parser::tokenBranches925[0], + &x64Parser::tokenBranches683[0], + &x64Parser::tokenBranches556[0], + &x64Parser::tokenBranches675[0], + &x64Parser::tokenBranches799[0], + &x64Parser::tokenBranches932[0], + &x64Parser::tokenBranches2339[0], + &x64Parser::tokenBranches2871[0], + &x64Parser::tokenBranches3169[0], + &x64Parser::tokenBranches2338[0], + &x64Parser::tokenBranches2337[0], + &x64Parser::tokenBranches2336[0], + &x64Parser::tokenBranches2348[0], + &x64Parser::tokenBranches2880[0], + &x64Parser::tokenBranches3178[0], + &x64Parser::tokenBranches2347[0], + &x64Parser::tokenBranches2335[0], + &x64Parser::tokenBranches555[0], + &x64Parser::tokenBranches1692[0], + &x64Parser::tokenBranches1701[0], + &x64Parser::tokenBranches1710[0], + &x64Parser::tokenBranches1691[0], + &x64Parser::tokenBranches1683[0], + &x64Parser::tokenBranches1820[0], + &x64Parser::tokenBranches1829[0], + &x64Parser::tokenBranches1838[0], + &x64Parser::tokenBranches1819[0], + &x64Parser::tokenBranches1811[0], + &x64Parser::tokenBranches2010[0], + &x64Parser::tokenBranches2019[0], + &x64Parser::tokenBranches2039[0], + &x64Parser::tokenBranches2050[0], + &x64Parser::tokenBranches2038[0], + &x64Parser::tokenBranches2028[0], + &x64Parser::tokenBranches2009[0], + &x64Parser::tokenBranches2001[0], + &x64Parser::tokenBranches1682[0], + &x64Parser::tokenBranches549[0], + &x64Parser::tokenBranches574[0], + &x64Parser::tokenBranches3276[0], + &x64Parser::tokenBranches3367[0], + &x64Parser::tokenBranches3459[0], + &x64Parser::tokenBranches4568[0], + &x64Parser::tokenBranches4944[0], + &x64Parser::tokenBranches5156[0], + &x64Parser::tokenBranches4567[0], + &x64Parser::tokenBranches4566[0], + &x64Parser::tokenBranches4565[0], + &x64Parser::tokenBranches4577[0], + &x64Parser::tokenBranches4953[0], + &x64Parser::tokenBranches5165[0], + &x64Parser::tokenBranches4576[0], + &x64Parser::tokenBranches4564[0], + &x64Parser::tokenBranches3275[0], + &x64Parser::tokenBranches3195[0], + &x64Parser::tokenBranches3336[0], + &x64Parser::tokenBranches3428[0], + &x64Parser::tokenBranches3520[0], + &x64Parser::tokenBranches3335[0], + &x64Parser::tokenBranches3235[0], + &x64Parser::tokenBranches3374[0], + &x64Parser::tokenBranches3466[0], + &x64Parser::tokenBranches4588[0], + &x64Parser::tokenBranches4964[0], + &x64Parser::tokenBranches5176[0], + &x64Parser::tokenBranches4587[0], + &x64Parser::tokenBranches4586[0], + &x64Parser::tokenBranches4585[0], + &x64Parser::tokenBranches4597[0], + &x64Parser::tokenBranches4973[0], + &x64Parser::tokenBranches5185[0], + &x64Parser::tokenBranches4596[0], + &x64Parser::tokenBranches4584[0], + &x64Parser::tokenBranches3234[0], + &x64Parser::tokenBranches3282[0], + &x64Parser::tokenBranches3571[0], + &x64Parser::tokenBranches3580[0], + &x64Parser::tokenBranches3589[0], + &x64Parser::tokenBranches3570[0], + &x64Parser::tokenBranches3562[0], + &x64Parser::tokenBranches3631[0], + &x64Parser::tokenBranches3640[0], + &x64Parser::tokenBranches3649[0], + &x64Parser::tokenBranches3630[0], + &x64Parser::tokenBranches3622[0], + &x64Parser::tokenBranches3677[0], + &x64Parser::tokenBranches3676[0], + &x64Parser::tokenBranches3668[0], + &x64Parser::tokenBranches3705[0], + &x64Parser::tokenBranches3704[0], + &x64Parser::tokenBranches3696[0], + &x64Parser::tokenBranches3561[0], + &x64Parser::tokenBranches3200[0], + &x64Parser::tokenBranches3289[0], + &x64Parser::tokenBranches3381[0], + &x64Parser::tokenBranches3473[0], + &x64Parser::tokenBranches4480[0], + &x64Parser::tokenBranches4856[0], + &x64Parser::tokenBranches5068[0], + &x64Parser::tokenBranches4479[0], + &x64Parser::tokenBranches4478[0], + &x64Parser::tokenBranches4548[0], + &x64Parser::tokenBranches4924[0], + &x64Parser::tokenBranches5136[0], + &x64Parser::tokenBranches4547[0], + &x64Parser::tokenBranches4546[0], + &x64Parser::tokenBranches4545[0], + &x64Parser::tokenBranches4557[0], + &x64Parser::tokenBranches4933[0], + &x64Parser::tokenBranches5145[0], + &x64Parser::tokenBranches4556[0], + &x64Parser::tokenBranches4544[0], + &x64Parser::tokenBranches3288[0], + &x64Parser::tokenBranches3815[0], + &x64Parser::tokenBranches3824[0], + &x64Parser::tokenBranches3833[0], + &x64Parser::tokenBranches3814[0], + &x64Parser::tokenBranches3806[0], + &x64Parser::tokenBranches3943[0], + &x64Parser::tokenBranches3952[0], + &x64Parser::tokenBranches3961[0], + &x64Parser::tokenBranches3942[0], + &x64Parser::tokenBranches3934[0], + &x64Parser::tokenBranches4245[0], + &x64Parser::tokenBranches4244[0], + &x64Parser::tokenBranches4236[0], + &x64Parser::tokenBranches3805[0], + &x64Parser::tokenBranches3205[0], + &x64Parser::tokenBranches3320[0], + &x64Parser::tokenBranches3412[0], + &x64Parser::tokenBranches3504[0], + &x64Parser::tokenBranches4489[0], + &x64Parser::tokenBranches4865[0], + &x64Parser::tokenBranches5077[0], + &x64Parser::tokenBranches4488[0], + &x64Parser::tokenBranches4487[0], + &x64Parser::tokenBranches4640[0], + &x64Parser::tokenBranches5016[0], + &x64Parser::tokenBranches5228[0], + &x64Parser::tokenBranches4639[0], + &x64Parser::tokenBranches4638[0], + &x64Parser::tokenBranches4637[0], + &x64Parser::tokenBranches4649[0], + &x64Parser::tokenBranches5025[0], + &x64Parser::tokenBranches5237[0], + &x64Parser::tokenBranches4648[0], + &x64Parser::tokenBranches4636[0], + &x64Parser::tokenBranches3319[0], + &x64Parser::tokenBranches4071[0], + &x64Parser::tokenBranches4080[0], + &x64Parser::tokenBranches4089[0], + &x64Parser::tokenBranches4070[0], + &x64Parser::tokenBranches4062[0], + &x64Parser::tokenBranches4199[0], + &x64Parser::tokenBranches4208[0], + &x64Parser::tokenBranches4217[0], + &x64Parser::tokenBranches4198[0], + &x64Parser::tokenBranches4190[0], + &x64Parser::tokenBranches4273[0], + &x64Parser::tokenBranches4272[0], + &x64Parser::tokenBranches4264[0], + &x64Parser::tokenBranches4061[0], + &x64Parser::tokenBranches3210[0], + &x64Parser::tokenBranches3345[0], + &x64Parser::tokenBranches3437[0], + &x64Parser::tokenBranches3529[0], + &x64Parser::tokenBranches3344[0], + &x64Parser::tokenBranches3242[0], + &x64Parser::tokenBranches3327[0], + &x64Parser::tokenBranches3419[0], + &x64Parser::tokenBranches3511[0], + &x64Parser::tokenBranches4660[0], + &x64Parser::tokenBranches5036[0], + &x64Parser::tokenBranches5248[0], + &x64Parser::tokenBranches4659[0], + &x64Parser::tokenBranches4658[0], + &x64Parser::tokenBranches4657[0], + &x64Parser::tokenBranches4669[0], + &x64Parser::tokenBranches5045[0], + &x64Parser::tokenBranches5257[0], + &x64Parser::tokenBranches4668[0], + &x64Parser::tokenBranches4656[0], + &x64Parser::tokenBranches3241[0], + &x64Parser::tokenBranches4315[0], + &x64Parser::tokenBranches4324[0], + &x64Parser::tokenBranches4333[0], + &x64Parser::tokenBranches4314[0], + &x64Parser::tokenBranches4306[0], + &x64Parser::tokenBranches4375[0], + &x64Parser::tokenBranches4384[0], + &x64Parser::tokenBranches4393[0], + &x64Parser::tokenBranches4374[0], + &x64Parser::tokenBranches4366[0], + &x64Parser::tokenBranches4437[0], + &x64Parser::tokenBranches4457[0], + &x64Parser::tokenBranches4456[0], + &x64Parser::tokenBranches4446[0], + &x64Parser::tokenBranches4436[0], + &x64Parser::tokenBranches4428[0], + &x64Parser::tokenBranches4305[0], + &x64Parser::tokenBranches3228[0], + &x64Parser::tokenBranches3255[0], + &x64Parser::tokenBranches17[0], + &x64Parser::tokenBranches16[0], + &x64Parser::tokenBranches183[0], + &x64Parser::tokenBranches329[0], + &x64Parser::tokenBranches182[0], + &x64Parser::tokenBranches23[0], + &x64Parser::tokenBranches129[0], + &x64Parser::tokenBranches275[0], + &x64Parser::tokenBranches421[0], + &x64Parser::tokenBranches22[0], + &x64Parser::tokenBranches21[0], + &x64Parser::tokenBranches190[0], + &x64Parser::tokenBranches336[0], + &x64Parser::tokenBranches189[0], + &x64Parser::tokenBranches28[0], + &x64Parser::tokenBranches155[0], + &x64Parser::tokenBranches301[0], + &x64Parser::tokenBranches447[0], + &x64Parser::tokenBranches27[0], + &x64Parser::tokenBranches26[0], + &x64Parser::tokenBranches249[0], + &x64Parser::tokenBranches395[0], + &x64Parser::tokenBranches248[0], + &x64Parser::tokenBranches73[0], + &x64Parser::tokenBranches579[0], + &x64Parser::tokenBranches689[0], + &x64Parser::tokenBranches813[0], + &x64Parser::tokenBranches2082[0], + &x64Parser::tokenBranches2614[0], + &x64Parser::tokenBranches2912[0], + &x64Parser::tokenBranches2081[0], + &x64Parser::tokenBranches2080[0], + &x64Parser::tokenBranches2079[0], + &x64Parser::tokenBranches2089[0], + &x64Parser::tokenBranches2621[0], + &x64Parser::tokenBranches2919[0], + &x64Parser::tokenBranches2088[0], + &x64Parser::tokenBranches2078[0], + &x64Parser::tokenBranches578[0], + &x64Parser::tokenBranches471[0], + &x64Parser::tokenBranches584[0], + &x64Parser::tokenBranches694[0], + &x64Parser::tokenBranches818[0], + &x64Parser::tokenBranches2057[0], + &x64Parser::tokenBranches2589[0], + &x64Parser::tokenBranches2887[0], + &x64Parser::tokenBranches2056[0], + &x64Parser::tokenBranches2055[0], + &x64Parser::tokenBranches2066[0], + &x64Parser::tokenBranches2598[0], + &x64Parser::tokenBranches2896[0], + &x64Parser::tokenBranches2065[0], + &x64Parser::tokenBranches2064[0], + &x64Parser::tokenBranches2063[0], + &x64Parser::tokenBranches2073[0], + &x64Parser::tokenBranches2605[0], + &x64Parser::tokenBranches2903[0], + &x64Parser::tokenBranches2072[0], + &x64Parser::tokenBranches2062[0], + &x64Parser::tokenBranches583[0], + &x64Parser::tokenBranches944[0], + &x64Parser::tokenBranches951[0], + &x64Parser::tokenBranches958[0], + &x64Parser::tokenBranches943[0], + &x64Parser::tokenBranches937[0], + &x64Parser::tokenBranches1072[0], + &x64Parser::tokenBranches1079[0], + &x64Parser::tokenBranches1086[0], + &x64Parser::tokenBranches1071[0], + &x64Parser::tokenBranches1065[0], + &x64Parser::tokenBranches1456[0], + &x64Parser::tokenBranches1463[0], + &x64Parser::tokenBranches1455[0], + &x64Parser::tokenBranches1449[0], + &x64Parser::tokenBranches936[0], + &x64Parser::tokenBranches474[0], + &x64Parser::tokenBranches617[0], + &x64Parser::tokenBranches741[0], + &x64Parser::tokenBranches865[0], + &x64Parser::tokenBranches2245[0], + &x64Parser::tokenBranches2777[0], + &x64Parser::tokenBranches3075[0], + &x64Parser::tokenBranches2244[0], + &x64Parser::tokenBranches2243[0], + &x64Parser::tokenBranches2242[0], + &x64Parser::tokenBranches2252[0], + &x64Parser::tokenBranches2784[0], + &x64Parser::tokenBranches3082[0], + &x64Parser::tokenBranches2251[0], + &x64Parser::tokenBranches2241[0], + &x64Parser::tokenBranches616[0], + &x64Parser::tokenBranches1200[0], + &x64Parser::tokenBranches1207[0], + &x64Parser::tokenBranches1214[0], + &x64Parser::tokenBranches1199[0], + &x64Parser::tokenBranches1193[0], + &x64Parser::tokenBranches1328[0], + &x64Parser::tokenBranches1335[0], + &x64Parser::tokenBranches1342[0], + &x64Parser::tokenBranches1327[0], + &x64Parser::tokenBranches1321[0], + &x64Parser::tokenBranches1550[0], + &x64Parser::tokenBranches1557[0], + &x64Parser::tokenBranches1549[0], + &x64Parser::tokenBranches1543[0], + &x64Parser::tokenBranches1192[0], + &x64Parser::tokenBranches477[0], + &x64Parser::tokenBranches629[0], + &x64Parser::tokenBranches753[0], + &x64Parser::tokenBranches877[0], + &x64Parser::tokenBranches628[0], + &x64Parser::tokenBranches485[0], + &x64Parser::tokenBranches622[0], + &x64Parser::tokenBranches746[0], + &x64Parser::tokenBranches870[0], + &x64Parser::tokenBranches2261[0], + &x64Parser::tokenBranches2793[0], + &x64Parser::tokenBranches3091[0], + &x64Parser::tokenBranches2260[0], + &x64Parser::tokenBranches2259[0], + &x64Parser::tokenBranches2258[0], + &x64Parser::tokenBranches2268[0], + &x64Parser::tokenBranches2800[0], + &x64Parser::tokenBranches3098[0], + &x64Parser::tokenBranches2267[0], + &x64Parser::tokenBranches2257[0], + &x64Parser::tokenBranches484[0], + &x64Parser::tokenBranches1594[0], + &x64Parser::tokenBranches1601[0], + &x64Parser::tokenBranches1608[0], + &x64Parser::tokenBranches1593[0], + &x64Parser::tokenBranches1587[0], + &x64Parser::tokenBranches1722[0], + &x64Parser::tokenBranches1729[0], + &x64Parser::tokenBranches1736[0], + &x64Parser::tokenBranches1721[0], + &x64Parser::tokenBranches1715[0], + &x64Parser::tokenBranches1850[0], + &x64Parser::tokenBranches1857[0], + &x64Parser::tokenBranches1873[0], + &x64Parser::tokenBranches1882[0], + &x64Parser::tokenBranches1872[0], + &x64Parser::tokenBranches1864[0], + &x64Parser::tokenBranches1849[0], + &x64Parser::tokenBranches1843[0], + &x64Parser::tokenBranches1586[0], + &x64Parser::tokenBranches480[0], + &x64Parser::tokenBranches559[0], + &x64Parser::tokenBranches3260[0], + &x64Parser::tokenBranches3350[0], + &x64Parser::tokenBranches3442[0], + &x64Parser::tokenBranches4514[0], + &x64Parser::tokenBranches4890[0], + &x64Parser::tokenBranches5102[0], + &x64Parser::tokenBranches4513[0], + &x64Parser::tokenBranches4512[0], + &x64Parser::tokenBranches4511[0], + &x64Parser::tokenBranches4521[0], + &x64Parser::tokenBranches4897[0], + &x64Parser::tokenBranches5109[0], + &x64Parser::tokenBranches4520[0], + &x64Parser::tokenBranches4510[0], + &x64Parser::tokenBranches3259[0], + &x64Parser::tokenBranches3181[0], + &x64Parser::tokenBranches3306[0], + &x64Parser::tokenBranches3398[0], + &x64Parser::tokenBranches3490[0], + &x64Parser::tokenBranches3305[0], + &x64Parser::tokenBranches3218[0], + &x64Parser::tokenBranches3355[0], + &x64Parser::tokenBranches3447[0], + &x64Parser::tokenBranches4530[0], + &x64Parser::tokenBranches4906[0], + &x64Parser::tokenBranches5118[0], + &x64Parser::tokenBranches4529[0], + &x64Parser::tokenBranches4528[0], + &x64Parser::tokenBranches4527[0], + &x64Parser::tokenBranches4537[0], + &x64Parser::tokenBranches4913[0], + &x64Parser::tokenBranches5125[0], + &x64Parser::tokenBranches4536[0], + &x64Parser::tokenBranches4526[0], + &x64Parser::tokenBranches3217[0], + &x64Parser::tokenBranches3264[0], + &x64Parser::tokenBranches3541[0], + &x64Parser::tokenBranches3548[0], + &x64Parser::tokenBranches3555[0], + &x64Parser::tokenBranches3540[0], + &x64Parser::tokenBranches3534[0], + &x64Parser::tokenBranches3601[0], + &x64Parser::tokenBranches3608[0], + &x64Parser::tokenBranches3615[0], + &x64Parser::tokenBranches3600[0], + &x64Parser::tokenBranches3594[0], + &x64Parser::tokenBranches3661[0], + &x64Parser::tokenBranches3660[0], + &x64Parser::tokenBranches3654[0], + &x64Parser::tokenBranches3689[0], + &x64Parser::tokenBranches3688[0], + &x64Parser::tokenBranches3682[0], + &x64Parser::tokenBranches3533[0], + &x64Parser::tokenBranches3184[0], + &x64Parser::tokenBranches3269[0], + &x64Parser::tokenBranches3360[0], + &x64Parser::tokenBranches3452[0], + &x64Parser::tokenBranches4464[0], + &x64Parser::tokenBranches4840[0], + &x64Parser::tokenBranches5052[0], + &x64Parser::tokenBranches4463[0], + &x64Parser::tokenBranches4462[0], + &x64Parser::tokenBranches4498[0], + &x64Parser::tokenBranches4874[0], + &x64Parser::tokenBranches5086[0], + &x64Parser::tokenBranches4497[0], + &x64Parser::tokenBranches4496[0], + &x64Parser::tokenBranches4495[0], + &x64Parser::tokenBranches4505[0], + &x64Parser::tokenBranches4881[0], + &x64Parser::tokenBranches5093[0], + &x64Parser::tokenBranches4504[0], + &x64Parser::tokenBranches4494[0], + &x64Parser::tokenBranches3268[0], + &x64Parser::tokenBranches3717[0], + &x64Parser::tokenBranches3724[0], + &x64Parser::tokenBranches3731[0], + &x64Parser::tokenBranches3716[0], + &x64Parser::tokenBranches3710[0], + &x64Parser::tokenBranches3845[0], + &x64Parser::tokenBranches3852[0], + &x64Parser::tokenBranches3859[0], + &x64Parser::tokenBranches3844[0], + &x64Parser::tokenBranches3838[0], + &x64Parser::tokenBranches4229[0], + &x64Parser::tokenBranches4228[0], + &x64Parser::tokenBranches4222[0], + &x64Parser::tokenBranches3709[0], + &x64Parser::tokenBranches3187[0], + &x64Parser::tokenBranches3294[0], + &x64Parser::tokenBranches3386[0], + &x64Parser::tokenBranches3478[0], + &x64Parser::tokenBranches4471[0], + &x64Parser::tokenBranches4847[0], + &x64Parser::tokenBranches5059[0], + &x64Parser::tokenBranches4470[0], + &x64Parser::tokenBranches4469[0], + &x64Parser::tokenBranches4606[0], + &x64Parser::tokenBranches4982[0], + &x64Parser::tokenBranches5194[0], + &x64Parser::tokenBranches4605[0], + &x64Parser::tokenBranches4604[0], + &x64Parser::tokenBranches4603[0], + &x64Parser::tokenBranches4613[0], + &x64Parser::tokenBranches4989[0], + &x64Parser::tokenBranches5201[0], + &x64Parser::tokenBranches4612[0], + &x64Parser::tokenBranches4602[0], + &x64Parser::tokenBranches3293[0], + &x64Parser::tokenBranches3973[0], + &x64Parser::tokenBranches3980[0], + &x64Parser::tokenBranches3987[0], + &x64Parser::tokenBranches3972[0], + &x64Parser::tokenBranches3966[0], + &x64Parser::tokenBranches4101[0], + &x64Parser::tokenBranches4108[0], + &x64Parser::tokenBranches4115[0], + &x64Parser::tokenBranches4100[0], + &x64Parser::tokenBranches4094[0], + &x64Parser::tokenBranches4257[0], + &x64Parser::tokenBranches4256[0], + &x64Parser::tokenBranches4250[0], + &x64Parser::tokenBranches3965[0], + &x64Parser::tokenBranches3190[0], + &x64Parser::tokenBranches3313[0], + &x64Parser::tokenBranches3405[0], + &x64Parser::tokenBranches3497[0], + &x64Parser::tokenBranches3312[0], + &x64Parser::tokenBranches3223[0], + &x64Parser::tokenBranches3299[0], + &x64Parser::tokenBranches3391[0], + &x64Parser::tokenBranches3483[0], + &x64Parser::tokenBranches4622[0], + &x64Parser::tokenBranches4998[0], + &x64Parser::tokenBranches5210[0], + &x64Parser::tokenBranches4621[0], + &x64Parser::tokenBranches4620[0], + &x64Parser::tokenBranches4619[0], + &x64Parser::tokenBranches4629[0], + &x64Parser::tokenBranches5005[0], + &x64Parser::tokenBranches5217[0], + &x64Parser::tokenBranches4628[0], + &x64Parser::tokenBranches4618[0], + &x64Parser::tokenBranches3222[0], + &x64Parser::tokenBranches4285[0], + &x64Parser::tokenBranches4292[0], + &x64Parser::tokenBranches4299[0], + &x64Parser::tokenBranches4284[0], + &x64Parser::tokenBranches4278[0], + &x64Parser::tokenBranches4345[0], + &x64Parser::tokenBranches4352[0], + &x64Parser::tokenBranches4359[0], + &x64Parser::tokenBranches4344[0], + &x64Parser::tokenBranches4338[0], + &x64Parser::tokenBranches4405[0], + &x64Parser::tokenBranches4421[0], + &x64Parser::tokenBranches4420[0], + &x64Parser::tokenBranches4412[0], + &x64Parser::tokenBranches4404[0], + &x64Parser::tokenBranches4398[0], + &x64Parser::tokenBranches4277[0], + &x64Parser::tokenBranches3213[0], + &x64Parser::tokenBranches3247[0], + &x64Parser::tokenBranches3246[0], + &x64Parser::tokenBranches3245[0], + &x64Parser::tokenBranches3250[0], + &x64Parser::tokenBranches2[0], + &x64Parser::tokenBranches1[0], }; Coding x64Parser::Coding1[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding2[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding3[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding4[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding5[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding6[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding7[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding8[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding9[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding10[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding11[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding12[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding13[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding14[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding15[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding16[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding17[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding18[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding19[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding20[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding21[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding22[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding23[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding24[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding25[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding26[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding27[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding28[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding29[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding30[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding31[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding32[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding33[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding34[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding35[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding36[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding37[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding38[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding39[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding40[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding41[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding42[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding43[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding44[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding45[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding46[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding47[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding48[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding49[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding50[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding51[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding52[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding53[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding54[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding55[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding56[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding57[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding58[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding59[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding60[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding61[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding62[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding63[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding64[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding65[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding66[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding67[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding68[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding69[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding70[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding71[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding72[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding73[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding74[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding75[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding76[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding77[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding78[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding79[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding80[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding81[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding82[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding83[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding84[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding85[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding86[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding87[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding88[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding89[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding90[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding91[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding92[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding93[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding94[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding95[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding96[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding97[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding98[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding99[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding100[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding101[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding102[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding103[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding104[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding105[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding106[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding107[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding108[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding109[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding110[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding111[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding112[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding113[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding114[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding115[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding116[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding117[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding118[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding119[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding120[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding121[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding122[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding123[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding124[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding125[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding126[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding127[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding128[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding129[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding130[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding131[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding132[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding133[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding134[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding135[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding136[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding137[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding138[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding139[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding140[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding141[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding142[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding143[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding144[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding145[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding146[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding147[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding148[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding149[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding150[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding151[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding152[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding153[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding154[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding155[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding156[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding157[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding158[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding159[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding160[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding161[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding162[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding163[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding164[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding165[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding166[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding167[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding168[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding169[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding170[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding171[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding172[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding173[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding174[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding175[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding176[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding177[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding178[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding179[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding180[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding181[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding182[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding183[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding184[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding185[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding186[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding187[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding188[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding189[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding190[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding191[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding192[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding193[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding194[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding195[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding196[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding197[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding198[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding199[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding200[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding201[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding202[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding203[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding204[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding205[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding206[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding207[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding208[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding209[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding210[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding211[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding212[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding213[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding214[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding215[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding216[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding217[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding218[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding219[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding220[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding221[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding222[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding223[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding224[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding225[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding226[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding227[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding228[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding229[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding230[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding231[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding232[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding233[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding234[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding235[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding236[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding237[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding238[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding239[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 1057, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 1057, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding240[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding241[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding242[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding243[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding244[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding245[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding246[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding247[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding248[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding249[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding250[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding251[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding252[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding253[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding254[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding255[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding256[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding257[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding258[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding259[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding260[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding261[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding262[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding263[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding264[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding265[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding266[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding267[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding268[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding269[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding270[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding271[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding272[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding273[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding274[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding275[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding276[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding277[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding278[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding279[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding280[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding281[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding282[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding283[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding284[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding285[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding286[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding287[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding288[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding289[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding290[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding291[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding292[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding293[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding294[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding295[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding296[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding297[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding298[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding299[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding300[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding301[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding302[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding303[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding304[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding305[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding306[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding307[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding308[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding309[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding310[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding311[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding312[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding313[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding314[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding315[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding316[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding317[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding318[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding319[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding320[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding321[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding322[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding323[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding324[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding325[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding326[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding327[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding328[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding329[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding330[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding331[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding332[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding333[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding334[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding335[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding336[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding337[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding338[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding339[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding340[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding341[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding342[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding343[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding344[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding345[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding346[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding347[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding348[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding349[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding350[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding351[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding352[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding353[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding354[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding355[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding356[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding357[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding358[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding359[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding360[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding361[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding362[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding363[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding364[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding365[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding366[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding367[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding368[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding369[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding370[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding371[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding372[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding373[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding374[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding375[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding376[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding377[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding378[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding379[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding380[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding381[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding382[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding383[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding384[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding385[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding386[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding387[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding388[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding389[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding390[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding391[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding392[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding393[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding394[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding395[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding396[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding397[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding398[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding399[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding400[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding401[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding402[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding403[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding404[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding405[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding406[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding407[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding408[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding409[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding410[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding411[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding412[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding413[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding414[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding415[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding416[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding417[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding418[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding419[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding420[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding421[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding422[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding423[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding424[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding425[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding426[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding427[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding428[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding429[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding430[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding431[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding432[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding433[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding434[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding435[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding436[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding437[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding438[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding439[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding440[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding441[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding442[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding443[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding444[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding445[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding446[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding447[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding448[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding449[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding450[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding451[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding452[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding453[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding454[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding455[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding456[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding457[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding458[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding459[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding460[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding461[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding462[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding463[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding464[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 39, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 39, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding465[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding466[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding467[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding468[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding469[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 26, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 26, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding470[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding471[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding472[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding473[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding474[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding475[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding476[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding477[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding478[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding479[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding480[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding481[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding482[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding483[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding484[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding485[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding486[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding487[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding488[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding489[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding490[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding491[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding492[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding493[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding494[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding495[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding496[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding497[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding498[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding499[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding500[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding501[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding502[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding503[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding504[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding505[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding506[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding507[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding508[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding509[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding510[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding511[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding512[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding513[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding514[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding515[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding516[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding517[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding518[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding519[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding520[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding521[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding522[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding523[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding524[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding525[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding526[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding527[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding528[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding529[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding530[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding531[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding532[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding533[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding534[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding535[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding536[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding537[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding538[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding539[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding540[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding541[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding542[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding543[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding544[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding545[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding546[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding547[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding548[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding549[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding550[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding551[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding552[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding553[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding554[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding555[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding556[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding557[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding558[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding559[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding560[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding561[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding562[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding563[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding564[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding565[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding566[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding567[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding568[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding569[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding570[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding571[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding572[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding573[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding574[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding575[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding576[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding577[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding578[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding579[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding580[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding581[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding582[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding583[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding584[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding585[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding586[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding587[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding588[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding589[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding590[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding591[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding592[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding593[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding594[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding595[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding596[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding597[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding598[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding599[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding600[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding601[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding602[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding603[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding604[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding605[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding606[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding607[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding608[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding609[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding610[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding611[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding612[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding613[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding614[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding615[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding616[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding617[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding618[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding619[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding620[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding621[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding622[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding623[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding624[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding625[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding626[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding627[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding628[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding629[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding630[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding631[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding632[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding633[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding634[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding635[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding636[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding637[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding638[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding639[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding640[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding641[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding642[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding643[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding644[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding645[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding646[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding647[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding648[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding649[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding650[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding651[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding652[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding653[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding654[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding655[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding656[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding657[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding658[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding659[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding660[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding661[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding662[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding663[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding664[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding665[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding666[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding667[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding668[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding669[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding670[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding671[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding672[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding673[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding674[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding675[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding676[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding677[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding678[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding679[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding680[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding681[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding682[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding683[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding684[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding685[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding686[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding687[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding688[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding689[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding690[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding691[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding692[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding693[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding694[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding695[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding696[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding697[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding698[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding699[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding700[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding701[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding702[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding703[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding704[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding705[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding706[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding707[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding708[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding709[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding710[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding711[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding712[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding713[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding714[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding715[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding716[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding717[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding718[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding719[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding720[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding721[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding722[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding723[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding724[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding725[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding726[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding727[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding728[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding729[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding730[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding731[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding732[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::Codings[732] = { - x64Parser::Coding1, x64Parser::Coding2, x64Parser::Coding3, x64Parser::Coding4, x64Parser::Coding5, - x64Parser::Coding6, x64Parser::Coding7, x64Parser::Coding8, x64Parser::Coding9, x64Parser::Coding10, - x64Parser::Coding11, x64Parser::Coding12, x64Parser::Coding13, x64Parser::Coding14, x64Parser::Coding15, - x64Parser::Coding16, x64Parser::Coding17, x64Parser::Coding18, x64Parser::Coding19, x64Parser::Coding20, - x64Parser::Coding21, x64Parser::Coding22, x64Parser::Coding23, x64Parser::Coding24, x64Parser::Coding25, - x64Parser::Coding26, x64Parser::Coding27, x64Parser::Coding28, x64Parser::Coding29, x64Parser::Coding30, - x64Parser::Coding31, x64Parser::Coding32, x64Parser::Coding33, x64Parser::Coding34, x64Parser::Coding35, - x64Parser::Coding36, x64Parser::Coding37, x64Parser::Coding38, x64Parser::Coding39, x64Parser::Coding40, - x64Parser::Coding41, x64Parser::Coding42, x64Parser::Coding43, x64Parser::Coding44, x64Parser::Coding45, - x64Parser::Coding46, x64Parser::Coding47, x64Parser::Coding48, x64Parser::Coding49, x64Parser::Coding50, - x64Parser::Coding51, x64Parser::Coding52, x64Parser::Coding53, x64Parser::Coding54, x64Parser::Coding55, - x64Parser::Coding56, x64Parser::Coding57, x64Parser::Coding58, x64Parser::Coding59, x64Parser::Coding60, - x64Parser::Coding61, x64Parser::Coding62, x64Parser::Coding63, x64Parser::Coding64, x64Parser::Coding65, - x64Parser::Coding66, x64Parser::Coding67, x64Parser::Coding68, x64Parser::Coding69, x64Parser::Coding70, - x64Parser::Coding71, x64Parser::Coding72, x64Parser::Coding73, x64Parser::Coding74, x64Parser::Coding75, - x64Parser::Coding76, x64Parser::Coding77, x64Parser::Coding78, x64Parser::Coding79, x64Parser::Coding80, - x64Parser::Coding81, x64Parser::Coding82, x64Parser::Coding83, x64Parser::Coding84, x64Parser::Coding85, - x64Parser::Coding86, x64Parser::Coding87, x64Parser::Coding88, x64Parser::Coding89, x64Parser::Coding90, - x64Parser::Coding91, x64Parser::Coding92, x64Parser::Coding93, x64Parser::Coding94, x64Parser::Coding95, - x64Parser::Coding96, x64Parser::Coding97, x64Parser::Coding98, x64Parser::Coding99, x64Parser::Coding100, - x64Parser::Coding101, x64Parser::Coding102, x64Parser::Coding103, x64Parser::Coding104, x64Parser::Coding105, - x64Parser::Coding106, x64Parser::Coding107, x64Parser::Coding108, x64Parser::Coding109, x64Parser::Coding110, - x64Parser::Coding111, x64Parser::Coding112, x64Parser::Coding113, x64Parser::Coding114, x64Parser::Coding115, - x64Parser::Coding116, x64Parser::Coding117, x64Parser::Coding118, x64Parser::Coding119, x64Parser::Coding120, - x64Parser::Coding121, x64Parser::Coding122, x64Parser::Coding123, x64Parser::Coding124, x64Parser::Coding125, - x64Parser::Coding126, x64Parser::Coding127, x64Parser::Coding128, x64Parser::Coding129, x64Parser::Coding130, - x64Parser::Coding131, x64Parser::Coding132, x64Parser::Coding133, x64Parser::Coding134, x64Parser::Coding135, - x64Parser::Coding136, x64Parser::Coding137, x64Parser::Coding138, x64Parser::Coding139, x64Parser::Coding140, - x64Parser::Coding141, x64Parser::Coding142, x64Parser::Coding143, x64Parser::Coding144, x64Parser::Coding145, - x64Parser::Coding146, x64Parser::Coding147, x64Parser::Coding148, x64Parser::Coding149, x64Parser::Coding150, - x64Parser::Coding151, x64Parser::Coding152, x64Parser::Coding153, x64Parser::Coding154, x64Parser::Coding155, - x64Parser::Coding156, x64Parser::Coding157, x64Parser::Coding158, x64Parser::Coding159, x64Parser::Coding160, - x64Parser::Coding161, x64Parser::Coding162, x64Parser::Coding163, x64Parser::Coding164, x64Parser::Coding165, - x64Parser::Coding166, x64Parser::Coding167, x64Parser::Coding168, x64Parser::Coding169, x64Parser::Coding170, - x64Parser::Coding171, x64Parser::Coding172, x64Parser::Coding173, x64Parser::Coding174, x64Parser::Coding175, - x64Parser::Coding176, x64Parser::Coding177, x64Parser::Coding178, x64Parser::Coding179, x64Parser::Coding180, - x64Parser::Coding181, x64Parser::Coding182, x64Parser::Coding183, x64Parser::Coding184, x64Parser::Coding185, - x64Parser::Coding186, x64Parser::Coding187, x64Parser::Coding188, x64Parser::Coding189, x64Parser::Coding190, - x64Parser::Coding191, x64Parser::Coding192, x64Parser::Coding193, x64Parser::Coding194, x64Parser::Coding195, - x64Parser::Coding196, x64Parser::Coding197, x64Parser::Coding198, x64Parser::Coding199, x64Parser::Coding200, - x64Parser::Coding201, x64Parser::Coding202, x64Parser::Coding203, x64Parser::Coding204, x64Parser::Coding205, - x64Parser::Coding206, x64Parser::Coding207, x64Parser::Coding208, x64Parser::Coding209, x64Parser::Coding210, - x64Parser::Coding211, x64Parser::Coding212, x64Parser::Coding213, x64Parser::Coding214, x64Parser::Coding215, - x64Parser::Coding216, x64Parser::Coding217, x64Parser::Coding218, x64Parser::Coding219, x64Parser::Coding220, - x64Parser::Coding221, x64Parser::Coding222, x64Parser::Coding223, x64Parser::Coding224, x64Parser::Coding225, - x64Parser::Coding226, x64Parser::Coding227, x64Parser::Coding228, x64Parser::Coding229, x64Parser::Coding230, - x64Parser::Coding231, x64Parser::Coding232, x64Parser::Coding233, x64Parser::Coding234, x64Parser::Coding235, - x64Parser::Coding236, x64Parser::Coding237, x64Parser::Coding238, x64Parser::Coding239, x64Parser::Coding240, - x64Parser::Coding241, x64Parser::Coding242, x64Parser::Coding243, x64Parser::Coding244, x64Parser::Coding245, - x64Parser::Coding246, x64Parser::Coding247, x64Parser::Coding248, x64Parser::Coding249, x64Parser::Coding250, - x64Parser::Coding251, x64Parser::Coding252, x64Parser::Coding253, x64Parser::Coding254, x64Parser::Coding255, - x64Parser::Coding256, x64Parser::Coding257, x64Parser::Coding258, x64Parser::Coding259, x64Parser::Coding260, - x64Parser::Coding261, x64Parser::Coding262, x64Parser::Coding263, x64Parser::Coding264, x64Parser::Coding265, - x64Parser::Coding266, x64Parser::Coding267, x64Parser::Coding268, x64Parser::Coding269, x64Parser::Coding270, - x64Parser::Coding271, x64Parser::Coding272, x64Parser::Coding273, x64Parser::Coding274, x64Parser::Coding275, - x64Parser::Coding276, x64Parser::Coding277, x64Parser::Coding278, x64Parser::Coding279, x64Parser::Coding280, - x64Parser::Coding281, x64Parser::Coding282, x64Parser::Coding283, x64Parser::Coding284, x64Parser::Coding285, - x64Parser::Coding286, x64Parser::Coding287, x64Parser::Coding288, x64Parser::Coding289, x64Parser::Coding290, - x64Parser::Coding291, x64Parser::Coding292, x64Parser::Coding293, x64Parser::Coding294, x64Parser::Coding295, - x64Parser::Coding296, x64Parser::Coding297, x64Parser::Coding298, x64Parser::Coding299, x64Parser::Coding300, - x64Parser::Coding301, x64Parser::Coding302, x64Parser::Coding303, x64Parser::Coding304, x64Parser::Coding305, - x64Parser::Coding306, x64Parser::Coding307, x64Parser::Coding308, x64Parser::Coding309, x64Parser::Coding310, - x64Parser::Coding311, x64Parser::Coding312, x64Parser::Coding313, x64Parser::Coding314, x64Parser::Coding315, - x64Parser::Coding316, x64Parser::Coding317, x64Parser::Coding318, x64Parser::Coding319, x64Parser::Coding320, - x64Parser::Coding321, x64Parser::Coding322, x64Parser::Coding323, x64Parser::Coding324, x64Parser::Coding325, - x64Parser::Coding326, x64Parser::Coding327, x64Parser::Coding328, x64Parser::Coding329, x64Parser::Coding330, - x64Parser::Coding331, x64Parser::Coding332, x64Parser::Coding333, x64Parser::Coding334, x64Parser::Coding335, - x64Parser::Coding336, x64Parser::Coding337, x64Parser::Coding338, x64Parser::Coding339, x64Parser::Coding340, - x64Parser::Coding341, x64Parser::Coding342, x64Parser::Coding343, x64Parser::Coding344, x64Parser::Coding345, - x64Parser::Coding346, x64Parser::Coding347, x64Parser::Coding348, x64Parser::Coding349, x64Parser::Coding350, - x64Parser::Coding351, x64Parser::Coding352, x64Parser::Coding353, x64Parser::Coding354, x64Parser::Coding355, - x64Parser::Coding356, x64Parser::Coding357, x64Parser::Coding358, x64Parser::Coding359, x64Parser::Coding360, - x64Parser::Coding361, x64Parser::Coding362, x64Parser::Coding363, x64Parser::Coding364, x64Parser::Coding365, - x64Parser::Coding366, x64Parser::Coding367, x64Parser::Coding368, x64Parser::Coding369, x64Parser::Coding370, - x64Parser::Coding371, x64Parser::Coding372, x64Parser::Coding373, x64Parser::Coding374, x64Parser::Coding375, - x64Parser::Coding376, x64Parser::Coding377, x64Parser::Coding378, x64Parser::Coding379, x64Parser::Coding380, - x64Parser::Coding381, x64Parser::Coding382, x64Parser::Coding383, x64Parser::Coding384, x64Parser::Coding385, - x64Parser::Coding386, x64Parser::Coding387, x64Parser::Coding388, x64Parser::Coding389, x64Parser::Coding390, - x64Parser::Coding391, x64Parser::Coding392, x64Parser::Coding393, x64Parser::Coding394, x64Parser::Coding395, - x64Parser::Coding396, x64Parser::Coding397, x64Parser::Coding398, x64Parser::Coding399, x64Parser::Coding400, - x64Parser::Coding401, x64Parser::Coding402, x64Parser::Coding403, x64Parser::Coding404, x64Parser::Coding405, - x64Parser::Coding406, x64Parser::Coding407, x64Parser::Coding408, x64Parser::Coding409, x64Parser::Coding410, - x64Parser::Coding411, x64Parser::Coding412, x64Parser::Coding413, x64Parser::Coding414, x64Parser::Coding415, - x64Parser::Coding416, x64Parser::Coding417, x64Parser::Coding418, x64Parser::Coding419, x64Parser::Coding420, - x64Parser::Coding421, x64Parser::Coding422, x64Parser::Coding423, x64Parser::Coding424, x64Parser::Coding425, - x64Parser::Coding426, x64Parser::Coding427, x64Parser::Coding428, x64Parser::Coding429, x64Parser::Coding430, - x64Parser::Coding431, x64Parser::Coding432, x64Parser::Coding433, x64Parser::Coding434, x64Parser::Coding435, - x64Parser::Coding436, x64Parser::Coding437, x64Parser::Coding438, x64Parser::Coding439, x64Parser::Coding440, - x64Parser::Coding441, x64Parser::Coding442, x64Parser::Coding443, x64Parser::Coding444, x64Parser::Coding445, - x64Parser::Coding446, x64Parser::Coding447, x64Parser::Coding448, x64Parser::Coding449, x64Parser::Coding450, - x64Parser::Coding451, x64Parser::Coding452, x64Parser::Coding453, x64Parser::Coding454, x64Parser::Coding455, - x64Parser::Coding456, x64Parser::Coding457, x64Parser::Coding458, x64Parser::Coding459, x64Parser::Coding460, - x64Parser::Coding461, x64Parser::Coding462, x64Parser::Coding463, x64Parser::Coding464, x64Parser::Coding465, - x64Parser::Coding466, x64Parser::Coding467, x64Parser::Coding468, x64Parser::Coding469, x64Parser::Coding470, - x64Parser::Coding471, x64Parser::Coding472, x64Parser::Coding473, x64Parser::Coding474, x64Parser::Coding475, - x64Parser::Coding476, x64Parser::Coding477, x64Parser::Coding478, x64Parser::Coding479, x64Parser::Coding480, - x64Parser::Coding481, x64Parser::Coding482, x64Parser::Coding483, x64Parser::Coding484, x64Parser::Coding485, - x64Parser::Coding486, x64Parser::Coding487, x64Parser::Coding488, x64Parser::Coding489, x64Parser::Coding490, - x64Parser::Coding491, x64Parser::Coding492, x64Parser::Coding493, x64Parser::Coding494, x64Parser::Coding495, - x64Parser::Coding496, x64Parser::Coding497, x64Parser::Coding498, x64Parser::Coding499, x64Parser::Coding500, - x64Parser::Coding501, x64Parser::Coding502, x64Parser::Coding503, x64Parser::Coding504, x64Parser::Coding505, - x64Parser::Coding506, x64Parser::Coding507, x64Parser::Coding508, x64Parser::Coding509, x64Parser::Coding510, - x64Parser::Coding511, x64Parser::Coding512, x64Parser::Coding513, x64Parser::Coding514, x64Parser::Coding515, - x64Parser::Coding516, x64Parser::Coding517, x64Parser::Coding518, x64Parser::Coding519, x64Parser::Coding520, - x64Parser::Coding521, x64Parser::Coding522, x64Parser::Coding523, x64Parser::Coding524, x64Parser::Coding525, - x64Parser::Coding526, x64Parser::Coding527, x64Parser::Coding528, x64Parser::Coding529, x64Parser::Coding530, - x64Parser::Coding531, x64Parser::Coding532, x64Parser::Coding533, x64Parser::Coding534, x64Parser::Coding535, - x64Parser::Coding536, x64Parser::Coding537, x64Parser::Coding538, x64Parser::Coding539, x64Parser::Coding540, - x64Parser::Coding541, x64Parser::Coding542, x64Parser::Coding543, x64Parser::Coding544, x64Parser::Coding545, - x64Parser::Coding546, x64Parser::Coding547, x64Parser::Coding548, x64Parser::Coding549, x64Parser::Coding550, - x64Parser::Coding551, x64Parser::Coding552, x64Parser::Coding553, x64Parser::Coding554, x64Parser::Coding555, - x64Parser::Coding556, x64Parser::Coding557, x64Parser::Coding558, x64Parser::Coding559, x64Parser::Coding560, - x64Parser::Coding561, x64Parser::Coding562, x64Parser::Coding563, x64Parser::Coding564, x64Parser::Coding565, - x64Parser::Coding566, x64Parser::Coding567, x64Parser::Coding568, x64Parser::Coding569, x64Parser::Coding570, - x64Parser::Coding571, x64Parser::Coding572, x64Parser::Coding573, x64Parser::Coding574, x64Parser::Coding575, - x64Parser::Coding576, x64Parser::Coding577, x64Parser::Coding578, x64Parser::Coding579, x64Parser::Coding580, - x64Parser::Coding581, x64Parser::Coding582, x64Parser::Coding583, x64Parser::Coding584, x64Parser::Coding585, - x64Parser::Coding586, x64Parser::Coding587, x64Parser::Coding588, x64Parser::Coding589, x64Parser::Coding590, - x64Parser::Coding591, x64Parser::Coding592, x64Parser::Coding593, x64Parser::Coding594, x64Parser::Coding595, - x64Parser::Coding596, x64Parser::Coding597, x64Parser::Coding598, x64Parser::Coding599, x64Parser::Coding600, - x64Parser::Coding601, x64Parser::Coding602, x64Parser::Coding603, x64Parser::Coding604, x64Parser::Coding605, - x64Parser::Coding606, x64Parser::Coding607, x64Parser::Coding608, x64Parser::Coding609, x64Parser::Coding610, - x64Parser::Coding611, x64Parser::Coding612, x64Parser::Coding613, x64Parser::Coding614, x64Parser::Coding615, - x64Parser::Coding616, x64Parser::Coding617, x64Parser::Coding618, x64Parser::Coding619, x64Parser::Coding620, - x64Parser::Coding621, x64Parser::Coding622, x64Parser::Coding623, x64Parser::Coding624, x64Parser::Coding625, - x64Parser::Coding626, x64Parser::Coding627, x64Parser::Coding628, x64Parser::Coding629, x64Parser::Coding630, - x64Parser::Coding631, x64Parser::Coding632, x64Parser::Coding633, x64Parser::Coding634, x64Parser::Coding635, - x64Parser::Coding636, x64Parser::Coding637, x64Parser::Coding638, x64Parser::Coding639, x64Parser::Coding640, - x64Parser::Coding641, x64Parser::Coding642, x64Parser::Coding643, x64Parser::Coding644, x64Parser::Coding645, - x64Parser::Coding646, x64Parser::Coding647, x64Parser::Coding648, x64Parser::Coding649, x64Parser::Coding650, - x64Parser::Coding651, x64Parser::Coding652, x64Parser::Coding653, x64Parser::Coding654, x64Parser::Coding655, - x64Parser::Coding656, x64Parser::Coding657, x64Parser::Coding658, x64Parser::Coding659, x64Parser::Coding660, - x64Parser::Coding661, x64Parser::Coding662, x64Parser::Coding663, x64Parser::Coding664, x64Parser::Coding665, - x64Parser::Coding666, x64Parser::Coding667, x64Parser::Coding668, x64Parser::Coding669, x64Parser::Coding670, - x64Parser::Coding671, x64Parser::Coding672, x64Parser::Coding673, x64Parser::Coding674, x64Parser::Coding675, - x64Parser::Coding676, x64Parser::Coding677, x64Parser::Coding678, x64Parser::Coding679, x64Parser::Coding680, - x64Parser::Coding681, x64Parser::Coding682, x64Parser::Coding683, x64Parser::Coding684, x64Parser::Coding685, - x64Parser::Coding686, x64Parser::Coding687, x64Parser::Coding688, x64Parser::Coding689, x64Parser::Coding690, - x64Parser::Coding691, x64Parser::Coding692, x64Parser::Coding693, x64Parser::Coding694, x64Parser::Coding695, - x64Parser::Coding696, x64Parser::Coding697, x64Parser::Coding698, x64Parser::Coding699, x64Parser::Coding700, - x64Parser::Coding701, x64Parser::Coding702, x64Parser::Coding703, x64Parser::Coding704, x64Parser::Coding705, - x64Parser::Coding706, x64Parser::Coding707, x64Parser::Coding708, x64Parser::Coding709, x64Parser::Coding710, - x64Parser::Coding711, x64Parser::Coding712, x64Parser::Coding713, x64Parser::Coding714, x64Parser::Coding715, - x64Parser::Coding716, x64Parser::Coding717, x64Parser::Coding718, x64Parser::Coding719, x64Parser::Coding720, - x64Parser::Coding721, x64Parser::Coding722, x64Parser::Coding723, x64Parser::Coding724, x64Parser::Coding725, - x64Parser::Coding726, x64Parser::Coding727, x64Parser::Coding728, x64Parser::Coding729, x64Parser::Coding730, - x64Parser::Coding731, x64Parser::Coding732, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding * x64Parser::Codings[732] = { + x64Parser::Coding1, + x64Parser::Coding2, + x64Parser::Coding3, + x64Parser::Coding4, + x64Parser::Coding5, + x64Parser::Coding6, + x64Parser::Coding7, + x64Parser::Coding8, + x64Parser::Coding9, + x64Parser::Coding10, + x64Parser::Coding11, + x64Parser::Coding12, + x64Parser::Coding13, + x64Parser::Coding14, + x64Parser::Coding15, + x64Parser::Coding16, + x64Parser::Coding17, + x64Parser::Coding18, + x64Parser::Coding19, + x64Parser::Coding20, + x64Parser::Coding21, + x64Parser::Coding22, + x64Parser::Coding23, + x64Parser::Coding24, + x64Parser::Coding25, + x64Parser::Coding26, + x64Parser::Coding27, + x64Parser::Coding28, + x64Parser::Coding29, + x64Parser::Coding30, + x64Parser::Coding31, + x64Parser::Coding32, + x64Parser::Coding33, + x64Parser::Coding34, + x64Parser::Coding35, + x64Parser::Coding36, + x64Parser::Coding37, + x64Parser::Coding38, + x64Parser::Coding39, + x64Parser::Coding40, + x64Parser::Coding41, + x64Parser::Coding42, + x64Parser::Coding43, + x64Parser::Coding44, + x64Parser::Coding45, + x64Parser::Coding46, + x64Parser::Coding47, + x64Parser::Coding48, + x64Parser::Coding49, + x64Parser::Coding50, + x64Parser::Coding51, + x64Parser::Coding52, + x64Parser::Coding53, + x64Parser::Coding54, + x64Parser::Coding55, + x64Parser::Coding56, + x64Parser::Coding57, + x64Parser::Coding58, + x64Parser::Coding59, + x64Parser::Coding60, + x64Parser::Coding61, + x64Parser::Coding62, + x64Parser::Coding63, + x64Parser::Coding64, + x64Parser::Coding65, + x64Parser::Coding66, + x64Parser::Coding67, + x64Parser::Coding68, + x64Parser::Coding69, + x64Parser::Coding70, + x64Parser::Coding71, + x64Parser::Coding72, + x64Parser::Coding73, + x64Parser::Coding74, + x64Parser::Coding75, + x64Parser::Coding76, + x64Parser::Coding77, + x64Parser::Coding78, + x64Parser::Coding79, + x64Parser::Coding80, + x64Parser::Coding81, + x64Parser::Coding82, + x64Parser::Coding83, + x64Parser::Coding84, + x64Parser::Coding85, + x64Parser::Coding86, + x64Parser::Coding87, + x64Parser::Coding88, + x64Parser::Coding89, + x64Parser::Coding90, + x64Parser::Coding91, + x64Parser::Coding92, + x64Parser::Coding93, + x64Parser::Coding94, + x64Parser::Coding95, + x64Parser::Coding96, + x64Parser::Coding97, + x64Parser::Coding98, + x64Parser::Coding99, + x64Parser::Coding100, + x64Parser::Coding101, + x64Parser::Coding102, + x64Parser::Coding103, + x64Parser::Coding104, + x64Parser::Coding105, + x64Parser::Coding106, + x64Parser::Coding107, + x64Parser::Coding108, + x64Parser::Coding109, + x64Parser::Coding110, + x64Parser::Coding111, + x64Parser::Coding112, + x64Parser::Coding113, + x64Parser::Coding114, + x64Parser::Coding115, + x64Parser::Coding116, + x64Parser::Coding117, + x64Parser::Coding118, + x64Parser::Coding119, + x64Parser::Coding120, + x64Parser::Coding121, + x64Parser::Coding122, + x64Parser::Coding123, + x64Parser::Coding124, + x64Parser::Coding125, + x64Parser::Coding126, + x64Parser::Coding127, + x64Parser::Coding128, + x64Parser::Coding129, + x64Parser::Coding130, + x64Parser::Coding131, + x64Parser::Coding132, + x64Parser::Coding133, + x64Parser::Coding134, + x64Parser::Coding135, + x64Parser::Coding136, + x64Parser::Coding137, + x64Parser::Coding138, + x64Parser::Coding139, + x64Parser::Coding140, + x64Parser::Coding141, + x64Parser::Coding142, + x64Parser::Coding143, + x64Parser::Coding144, + x64Parser::Coding145, + x64Parser::Coding146, + x64Parser::Coding147, + x64Parser::Coding148, + x64Parser::Coding149, + x64Parser::Coding150, + x64Parser::Coding151, + x64Parser::Coding152, + x64Parser::Coding153, + x64Parser::Coding154, + x64Parser::Coding155, + x64Parser::Coding156, + x64Parser::Coding157, + x64Parser::Coding158, + x64Parser::Coding159, + x64Parser::Coding160, + x64Parser::Coding161, + x64Parser::Coding162, + x64Parser::Coding163, + x64Parser::Coding164, + x64Parser::Coding165, + x64Parser::Coding166, + x64Parser::Coding167, + x64Parser::Coding168, + x64Parser::Coding169, + x64Parser::Coding170, + x64Parser::Coding171, + x64Parser::Coding172, + x64Parser::Coding173, + x64Parser::Coding174, + x64Parser::Coding175, + x64Parser::Coding176, + x64Parser::Coding177, + x64Parser::Coding178, + x64Parser::Coding179, + x64Parser::Coding180, + x64Parser::Coding181, + x64Parser::Coding182, + x64Parser::Coding183, + x64Parser::Coding184, + x64Parser::Coding185, + x64Parser::Coding186, + x64Parser::Coding187, + x64Parser::Coding188, + x64Parser::Coding189, + x64Parser::Coding190, + x64Parser::Coding191, + x64Parser::Coding192, + x64Parser::Coding193, + x64Parser::Coding194, + x64Parser::Coding195, + x64Parser::Coding196, + x64Parser::Coding197, + x64Parser::Coding198, + x64Parser::Coding199, + x64Parser::Coding200, + x64Parser::Coding201, + x64Parser::Coding202, + x64Parser::Coding203, + x64Parser::Coding204, + x64Parser::Coding205, + x64Parser::Coding206, + x64Parser::Coding207, + x64Parser::Coding208, + x64Parser::Coding209, + x64Parser::Coding210, + x64Parser::Coding211, + x64Parser::Coding212, + x64Parser::Coding213, + x64Parser::Coding214, + x64Parser::Coding215, + x64Parser::Coding216, + x64Parser::Coding217, + x64Parser::Coding218, + x64Parser::Coding219, + x64Parser::Coding220, + x64Parser::Coding221, + x64Parser::Coding222, + x64Parser::Coding223, + x64Parser::Coding224, + x64Parser::Coding225, + x64Parser::Coding226, + x64Parser::Coding227, + x64Parser::Coding228, + x64Parser::Coding229, + x64Parser::Coding230, + x64Parser::Coding231, + x64Parser::Coding232, + x64Parser::Coding233, + x64Parser::Coding234, + x64Parser::Coding235, + x64Parser::Coding236, + x64Parser::Coding237, + x64Parser::Coding238, + x64Parser::Coding239, + x64Parser::Coding240, + x64Parser::Coding241, + x64Parser::Coding242, + x64Parser::Coding243, + x64Parser::Coding244, + x64Parser::Coding245, + x64Parser::Coding246, + x64Parser::Coding247, + x64Parser::Coding248, + x64Parser::Coding249, + x64Parser::Coding250, + x64Parser::Coding251, + x64Parser::Coding252, + x64Parser::Coding253, + x64Parser::Coding254, + x64Parser::Coding255, + x64Parser::Coding256, + x64Parser::Coding257, + x64Parser::Coding258, + x64Parser::Coding259, + x64Parser::Coding260, + x64Parser::Coding261, + x64Parser::Coding262, + x64Parser::Coding263, + x64Parser::Coding264, + x64Parser::Coding265, + x64Parser::Coding266, + x64Parser::Coding267, + x64Parser::Coding268, + x64Parser::Coding269, + x64Parser::Coding270, + x64Parser::Coding271, + x64Parser::Coding272, + x64Parser::Coding273, + x64Parser::Coding274, + x64Parser::Coding275, + x64Parser::Coding276, + x64Parser::Coding277, + x64Parser::Coding278, + x64Parser::Coding279, + x64Parser::Coding280, + x64Parser::Coding281, + x64Parser::Coding282, + x64Parser::Coding283, + x64Parser::Coding284, + x64Parser::Coding285, + x64Parser::Coding286, + x64Parser::Coding287, + x64Parser::Coding288, + x64Parser::Coding289, + x64Parser::Coding290, + x64Parser::Coding291, + x64Parser::Coding292, + x64Parser::Coding293, + x64Parser::Coding294, + x64Parser::Coding295, + x64Parser::Coding296, + x64Parser::Coding297, + x64Parser::Coding298, + x64Parser::Coding299, + x64Parser::Coding300, + x64Parser::Coding301, + x64Parser::Coding302, + x64Parser::Coding303, + x64Parser::Coding304, + x64Parser::Coding305, + x64Parser::Coding306, + x64Parser::Coding307, + x64Parser::Coding308, + x64Parser::Coding309, + x64Parser::Coding310, + x64Parser::Coding311, + x64Parser::Coding312, + x64Parser::Coding313, + x64Parser::Coding314, + x64Parser::Coding315, + x64Parser::Coding316, + x64Parser::Coding317, + x64Parser::Coding318, + x64Parser::Coding319, + x64Parser::Coding320, + x64Parser::Coding321, + x64Parser::Coding322, + x64Parser::Coding323, + x64Parser::Coding324, + x64Parser::Coding325, + x64Parser::Coding326, + x64Parser::Coding327, + x64Parser::Coding328, + x64Parser::Coding329, + x64Parser::Coding330, + x64Parser::Coding331, + x64Parser::Coding332, + x64Parser::Coding333, + x64Parser::Coding334, + x64Parser::Coding335, + x64Parser::Coding336, + x64Parser::Coding337, + x64Parser::Coding338, + x64Parser::Coding339, + x64Parser::Coding340, + x64Parser::Coding341, + x64Parser::Coding342, + x64Parser::Coding343, + x64Parser::Coding344, + x64Parser::Coding345, + x64Parser::Coding346, + x64Parser::Coding347, + x64Parser::Coding348, + x64Parser::Coding349, + x64Parser::Coding350, + x64Parser::Coding351, + x64Parser::Coding352, + x64Parser::Coding353, + x64Parser::Coding354, + x64Parser::Coding355, + x64Parser::Coding356, + x64Parser::Coding357, + x64Parser::Coding358, + x64Parser::Coding359, + x64Parser::Coding360, + x64Parser::Coding361, + x64Parser::Coding362, + x64Parser::Coding363, + x64Parser::Coding364, + x64Parser::Coding365, + x64Parser::Coding366, + x64Parser::Coding367, + x64Parser::Coding368, + x64Parser::Coding369, + x64Parser::Coding370, + x64Parser::Coding371, + x64Parser::Coding372, + x64Parser::Coding373, + x64Parser::Coding374, + x64Parser::Coding375, + x64Parser::Coding376, + x64Parser::Coding377, + x64Parser::Coding378, + x64Parser::Coding379, + x64Parser::Coding380, + x64Parser::Coding381, + x64Parser::Coding382, + x64Parser::Coding383, + x64Parser::Coding384, + x64Parser::Coding385, + x64Parser::Coding386, + x64Parser::Coding387, + x64Parser::Coding388, + x64Parser::Coding389, + x64Parser::Coding390, + x64Parser::Coding391, + x64Parser::Coding392, + x64Parser::Coding393, + x64Parser::Coding394, + x64Parser::Coding395, + x64Parser::Coding396, + x64Parser::Coding397, + x64Parser::Coding398, + x64Parser::Coding399, + x64Parser::Coding400, + x64Parser::Coding401, + x64Parser::Coding402, + x64Parser::Coding403, + x64Parser::Coding404, + x64Parser::Coding405, + x64Parser::Coding406, + x64Parser::Coding407, + x64Parser::Coding408, + x64Parser::Coding409, + x64Parser::Coding410, + x64Parser::Coding411, + x64Parser::Coding412, + x64Parser::Coding413, + x64Parser::Coding414, + x64Parser::Coding415, + x64Parser::Coding416, + x64Parser::Coding417, + x64Parser::Coding418, + x64Parser::Coding419, + x64Parser::Coding420, + x64Parser::Coding421, + x64Parser::Coding422, + x64Parser::Coding423, + x64Parser::Coding424, + x64Parser::Coding425, + x64Parser::Coding426, + x64Parser::Coding427, + x64Parser::Coding428, + x64Parser::Coding429, + x64Parser::Coding430, + x64Parser::Coding431, + x64Parser::Coding432, + x64Parser::Coding433, + x64Parser::Coding434, + x64Parser::Coding435, + x64Parser::Coding436, + x64Parser::Coding437, + x64Parser::Coding438, + x64Parser::Coding439, + x64Parser::Coding440, + x64Parser::Coding441, + x64Parser::Coding442, + x64Parser::Coding443, + x64Parser::Coding444, + x64Parser::Coding445, + x64Parser::Coding446, + x64Parser::Coding447, + x64Parser::Coding448, + x64Parser::Coding449, + x64Parser::Coding450, + x64Parser::Coding451, + x64Parser::Coding452, + x64Parser::Coding453, + x64Parser::Coding454, + x64Parser::Coding455, + x64Parser::Coding456, + x64Parser::Coding457, + x64Parser::Coding458, + x64Parser::Coding459, + x64Parser::Coding460, + x64Parser::Coding461, + x64Parser::Coding462, + x64Parser::Coding463, + x64Parser::Coding464, + x64Parser::Coding465, + x64Parser::Coding466, + x64Parser::Coding467, + x64Parser::Coding468, + x64Parser::Coding469, + x64Parser::Coding470, + x64Parser::Coding471, + x64Parser::Coding472, + x64Parser::Coding473, + x64Parser::Coding474, + x64Parser::Coding475, + x64Parser::Coding476, + x64Parser::Coding477, + x64Parser::Coding478, + x64Parser::Coding479, + x64Parser::Coding480, + x64Parser::Coding481, + x64Parser::Coding482, + x64Parser::Coding483, + x64Parser::Coding484, + x64Parser::Coding485, + x64Parser::Coding486, + x64Parser::Coding487, + x64Parser::Coding488, + x64Parser::Coding489, + x64Parser::Coding490, + x64Parser::Coding491, + x64Parser::Coding492, + x64Parser::Coding493, + x64Parser::Coding494, + x64Parser::Coding495, + x64Parser::Coding496, + x64Parser::Coding497, + x64Parser::Coding498, + x64Parser::Coding499, + x64Parser::Coding500, + x64Parser::Coding501, + x64Parser::Coding502, + x64Parser::Coding503, + x64Parser::Coding504, + x64Parser::Coding505, + x64Parser::Coding506, + x64Parser::Coding507, + x64Parser::Coding508, + x64Parser::Coding509, + x64Parser::Coding510, + x64Parser::Coding511, + x64Parser::Coding512, + x64Parser::Coding513, + x64Parser::Coding514, + x64Parser::Coding515, + x64Parser::Coding516, + x64Parser::Coding517, + x64Parser::Coding518, + x64Parser::Coding519, + x64Parser::Coding520, + x64Parser::Coding521, + x64Parser::Coding522, + x64Parser::Coding523, + x64Parser::Coding524, + x64Parser::Coding525, + x64Parser::Coding526, + x64Parser::Coding527, + x64Parser::Coding528, + x64Parser::Coding529, + x64Parser::Coding530, + x64Parser::Coding531, + x64Parser::Coding532, + x64Parser::Coding533, + x64Parser::Coding534, + x64Parser::Coding535, + x64Parser::Coding536, + x64Parser::Coding537, + x64Parser::Coding538, + x64Parser::Coding539, + x64Parser::Coding540, + x64Parser::Coding541, + x64Parser::Coding542, + x64Parser::Coding543, + x64Parser::Coding544, + x64Parser::Coding545, + x64Parser::Coding546, + x64Parser::Coding547, + x64Parser::Coding548, + x64Parser::Coding549, + x64Parser::Coding550, + x64Parser::Coding551, + x64Parser::Coding552, + x64Parser::Coding553, + x64Parser::Coding554, + x64Parser::Coding555, + x64Parser::Coding556, + x64Parser::Coding557, + x64Parser::Coding558, + x64Parser::Coding559, + x64Parser::Coding560, + x64Parser::Coding561, + x64Parser::Coding562, + x64Parser::Coding563, + x64Parser::Coding564, + x64Parser::Coding565, + x64Parser::Coding566, + x64Parser::Coding567, + x64Parser::Coding568, + x64Parser::Coding569, + x64Parser::Coding570, + x64Parser::Coding571, + x64Parser::Coding572, + x64Parser::Coding573, + x64Parser::Coding574, + x64Parser::Coding575, + x64Parser::Coding576, + x64Parser::Coding577, + x64Parser::Coding578, + x64Parser::Coding579, + x64Parser::Coding580, + x64Parser::Coding581, + x64Parser::Coding582, + x64Parser::Coding583, + x64Parser::Coding584, + x64Parser::Coding585, + x64Parser::Coding586, + x64Parser::Coding587, + x64Parser::Coding588, + x64Parser::Coding589, + x64Parser::Coding590, + x64Parser::Coding591, + x64Parser::Coding592, + x64Parser::Coding593, + x64Parser::Coding594, + x64Parser::Coding595, + x64Parser::Coding596, + x64Parser::Coding597, + x64Parser::Coding598, + x64Parser::Coding599, + x64Parser::Coding600, + x64Parser::Coding601, + x64Parser::Coding602, + x64Parser::Coding603, + x64Parser::Coding604, + x64Parser::Coding605, + x64Parser::Coding606, + x64Parser::Coding607, + x64Parser::Coding608, + x64Parser::Coding609, + x64Parser::Coding610, + x64Parser::Coding611, + x64Parser::Coding612, + x64Parser::Coding613, + x64Parser::Coding614, + x64Parser::Coding615, + x64Parser::Coding616, + x64Parser::Coding617, + x64Parser::Coding618, + x64Parser::Coding619, + x64Parser::Coding620, + x64Parser::Coding621, + x64Parser::Coding622, + x64Parser::Coding623, + x64Parser::Coding624, + x64Parser::Coding625, + x64Parser::Coding626, + x64Parser::Coding627, + x64Parser::Coding628, + x64Parser::Coding629, + x64Parser::Coding630, + x64Parser::Coding631, + x64Parser::Coding632, + x64Parser::Coding633, + x64Parser::Coding634, + x64Parser::Coding635, + x64Parser::Coding636, + x64Parser::Coding637, + x64Parser::Coding638, + x64Parser::Coding639, + x64Parser::Coding640, + x64Parser::Coding641, + x64Parser::Coding642, + x64Parser::Coding643, + x64Parser::Coding644, + x64Parser::Coding645, + x64Parser::Coding646, + x64Parser::Coding647, + x64Parser::Coding648, + x64Parser::Coding649, + x64Parser::Coding650, + x64Parser::Coding651, + x64Parser::Coding652, + x64Parser::Coding653, + x64Parser::Coding654, + x64Parser::Coding655, + x64Parser::Coding656, + x64Parser::Coding657, + x64Parser::Coding658, + x64Parser::Coding659, + x64Parser::Coding660, + x64Parser::Coding661, + x64Parser::Coding662, + x64Parser::Coding663, + x64Parser::Coding664, + x64Parser::Coding665, + x64Parser::Coding666, + x64Parser::Coding667, + x64Parser::Coding668, + x64Parser::Coding669, + x64Parser::Coding670, + x64Parser::Coding671, + x64Parser::Coding672, + x64Parser::Coding673, + x64Parser::Coding674, + x64Parser::Coding675, + x64Parser::Coding676, + x64Parser::Coding677, + x64Parser::Coding678, + x64Parser::Coding679, + x64Parser::Coding680, + x64Parser::Coding681, + x64Parser::Coding682, + x64Parser::Coding683, + x64Parser::Coding684, + x64Parser::Coding685, + x64Parser::Coding686, + x64Parser::Coding687, + x64Parser::Coding688, + x64Parser::Coding689, + x64Parser::Coding690, + x64Parser::Coding691, + x64Parser::Coding692, + x64Parser::Coding693, + x64Parser::Coding694, + x64Parser::Coding695, + x64Parser::Coding696, + x64Parser::Coding697, + x64Parser::Coding698, + x64Parser::Coding699, + x64Parser::Coding700, + x64Parser::Coding701, + x64Parser::Coding702, + x64Parser::Coding703, + x64Parser::Coding704, + x64Parser::Coding705, + x64Parser::Coding706, + x64Parser::Coding707, + x64Parser::Coding708, + x64Parser::Coding709, + x64Parser::Coding710, + x64Parser::Coding711, + x64Parser::Coding712, + x64Parser::Coding713, + x64Parser::Coding714, + x64Parser::Coding715, + x64Parser::Coding716, + x64Parser::Coding717, + x64Parser::Coding718, + x64Parser::Coding719, + x64Parser::Coding720, + x64Parser::Coding721, + x64Parser::Coding722, + x64Parser::Coding723, + x64Parser::Coding724, + x64Parser::Coding725, + x64Parser::Coding726, + x64Parser::Coding727, + x64Parser::Coding728, + x64Parser::Coding729, + x64Parser::Coding730, + x64Parser::Coding731, + x64Parser::Coding732, }; Coding x64Parser::prefixCoding1[] = { - {CODING_NAME("a16") Coding::stateFunc, 1}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("a16") Coding::stateFunc, 1 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding2[] = { - {CODING_NAME("a32") Coding::stateFunc, 2}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("a32") Coding::stateFunc, 2 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding3[] = { - {CODING_NAME("lock")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lock") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding4[] = { - {CODING_NAME("o16") Coding::stateFunc, 4}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("o16") Coding::stateFunc, 4 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding5[] = { - {CODING_NAME("o32") Coding::stateFunc, 5}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("o32") Coding::stateFunc, 5 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding6[] = { - {CODING_NAME("rep")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rep") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding7[] = { - {CODING_NAME("repe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding8[] = { - {CODING_NAME("repne")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding9[] = { - {CODING_NAME("repnz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repnz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding10[] = { - {CODING_NAME("repz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::prefixCodings[] = { - x64Parser::prefixCoding1, x64Parser::prefixCoding2, x64Parser::prefixCoding3, x64Parser::prefixCoding4, - x64Parser::prefixCoding5, x64Parser::prefixCoding6, x64Parser::prefixCoding7, x64Parser::prefixCoding8, - x64Parser::prefixCoding9, x64Parser::prefixCoding10, + { CODING_NAME("repz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding *x64Parser::prefixCodings[] = { + x64Parser::prefixCoding1, + x64Parser::prefixCoding2, + x64Parser::prefixCoding3, + x64Parser::prefixCoding4, + x64Parser::prefixCoding5, + x64Parser::prefixCoding6, + x64Parser::prefixCoding7, + x64Parser::prefixCoding8, + x64Parser::prefixCoding9, + x64Parser::prefixCoding10, }; bool x64Parser::MatchesToken(int token, int tokenPos) { - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::TOKEN && - inputTokens[tokenPos]->val->ival == token; -} -bool x64Parser::MatchesRegister(int reg, int tokenPos) -{ - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && - inputTokens[tokenPos]->val->ival == reg; -} -bool x64Parser::MatchesRegisterClass(int cclass, int tokenPos) -{ - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && - (registerDataIndirect[cclass][inputTokens[tokenPos]->val->ival >> 3] & (1 << (inputTokens[tokenPos]->val->ival & 7))); -} -bool x64Parser::ParseAddresses(x64Operand& operand, int addrClass, int& tokenPos) -{ - int level = 0; - bool rv = false; - x64Token* t = tokenBranches1; - while (t->type != x64Token::EOT) - { - bool matches = false; - if (t->addrClass[addrClass >> 3] & (1 << (addrClass & 7))) - { - switch (t->type) - { - case x64Token::EMPTY: - matches = true; - break; - case x64Token::TOKEN: - matches = MatchesToken(t->id, tokenPos); - break; - case x64Token::REGISTER: - matches = MatchesRegister(t->id, tokenPos); - break; - case x64Token::REGISTERCLASS: - matches = MatchesRegisterClass(t->id, tokenPos); - break; - case x64Token::NUMBER: - if (tokenPos < inputTokens.size()) - matches = (this->*numberFuncs[t->id])(tokenPos); - break; - default: - matches = false; - break; - } - } - if (!matches) - { - if (t->level > level) - { - t = t->next; - continue; - } - } - else - level = t->level; - if (matches) - { - if (t->tokenFunc) - (this->*(t->tokenFunc))(operand, tokenPos); - if (t->eos && (tokenPos == inputTokens.size() - 1 || !t->next)) - { - rv = true; - break; - } - t = t->next; - tokenPos++; - } - else - { - t++; - } - } - return rv; + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::TOKEN && inputTokens[tokenPos]->val->ival == token; +} + bool x64Parser::MatchesRegister(int reg, int tokenPos) +{ + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && inputTokens[tokenPos]->val->ival == reg; +} + bool x64Parser::MatchesRegisterClass(int cclass, int tokenPos) +{ + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && (registerDataIndirect[cclass][inputTokens[tokenPos]->val->ival >> 3] & (1 << (inputTokens[tokenPos]->val->ival & 7))); +} +bool x64Parser::ParseAddresses(x64Operand &operand, int addrClass, int &tokenPos) +{ + int level = 0; + bool rv = false; + x64Token *t = tokenBranches1; + while (t->type != x64Token::EOT) + { + bool matches = false; + if (t->addrClass[addrClass >> 3] & (1 << (addrClass & 7))) + { + switch (t->type) + { + case x64Token::EMPTY: + matches = true; + break; + case x64Token::TOKEN: + matches = MatchesToken(t->id, tokenPos); + break; + case x64Token::REGISTER: + matches = MatchesRegister(t->id, tokenPos); + break; + case x64Token::REGISTERCLASS: + matches = MatchesRegisterClass(t->id, tokenPos); + break; + case x64Token::NUMBER: + if (tokenPos < inputTokens.size()) + matches = (this->*numberFuncs[t->id])(tokenPos); + break; + default: + matches = false; + break; + } + } + if (!matches) + { + if (t->level > level) + { + t = t->next; + continue; + } + } + else + level = t->level; + if (matches) + { + if (t->tokenFunc) + (this->*(t->tokenFunc))(operand, tokenPos); + if (t->eos && (tokenPos == inputTokens.size()-1 || !t->next)) + { + rv = true; + break; + } + t = t->next; + tokenPos++; + } + else + { + t++; + } + } + return rv; } -asmError x64Parser::ParseOperands2(x64Token* tokenList, x64Operand& operand, int tokenPos, int level) -{ - asmError rv = AERR_OPERAND; - x64Token* t = tokenList; - while (t && t->type != x64Token::EOT) - { - bool matches = false; - int last = tokenPos; - switch (t->type) - { - case x64Token::EMPTY: - matches = true; - break; - case x64Token::TOKEN: - matches = MatchesToken(t->id, tokenPos); - break; - case x64Token::REGISTER: - matches = MatchesRegister(t->id, tokenPos); - break; - case x64Token::REGISTERCLASS: - matches = MatchesRegisterClass(t->id, tokenPos); - break; - case x64Token::ADDRESSCLASS: - matches = ParseAddresses(operand, t->id, tokenPos); - break; - case x64Token::NUMBER: - if (tokenPos < inputTokens.size()) - matches = (this->*numberFuncs[t->id])(tokenPos); - break; - default: - matches = false; - break; - } - if (!matches) - { - if (t->level > level) - { - rv = ParseOperands2(t->next, operand, tokenPos, t->level); - if (rv == AERR_NONE) - break; - } - } - else - { - if (t->tokenFunc) - (this->*(t->tokenFunc))(operand, last); - if (t->eos && (!t->next || tokenPos == inputTokens.size() - 1)) - { - bool ok = false; - if (operand.operandCoding != -1) - ok = CheckCoding(operand, Codings[operand.operandCoding]); - else if (operand.addressCoding != -1) - ok = CheckCoding(operand, Codings[operand.addressCoding]); - if (ok) - { - if (tokenPos >= (int)(inputTokens.size() - 1)) - eol = true; - rv = AERR_NONE; - break; - } - operand.operandCoding = -1; - operand.addressCoding = -1; - } - if (tokenPos < inputTokens.size()) - { - rv = ParseOperands2(t->next, operand, tokenPos + 1, t->level); - if (rv == AERR_NONE) - break; - } - } - tokenPos = last; - t++; - } - return rv; +asmError x64Parser::ParseOperands2(x64Token *tokenList, x64Operand &operand, int tokenPos, int level) +{ + asmError rv = AERR_OPERAND; + x64Token *t = tokenList; + while (t && t->type != x64Token::EOT) + { + bool matches = false; + int last = tokenPos; + switch (t->type) + { + case x64Token::EMPTY: + matches = true; + break; + case x64Token::TOKEN: + matches = MatchesToken(t->id, tokenPos); + break; + case x64Token::REGISTER: + matches = MatchesRegister(t->id, tokenPos); + break; + case x64Token::REGISTERCLASS: + matches = MatchesRegisterClass(t->id,tokenPos); + break; + case x64Token::ADDRESSCLASS: + matches = ParseAddresses(operand, t->id, tokenPos); + break; + case x64Token::NUMBER: + if (tokenPos < inputTokens.size()) + matches = (this->*numberFuncs[t->id])(tokenPos); + break; + default: + matches = false; + break; + } + if (!matches) + { + if (t->level > level) + { + rv = ParseOperands2(t->next, operand, tokenPos, t->level); + if (rv == AERR_NONE) + break; + } + } + else + { + if (t->tokenFunc) + (this->*(t->tokenFunc))(operand, last); + if (t->eos && (!t->next || tokenPos == inputTokens.size()-1)) + { + bool ok = false; + if (operand.operandCoding != -1) + ok = CheckCoding(operand, Codings[operand.operandCoding]); + else if (operand.addressCoding != -1) + ok = CheckCoding(operand, Codings[operand.addressCoding]); + if (ok) + { + if (tokenPos >= (int)(inputTokens.size()-1)) + eol = true; + rv = AERR_NONE; + break; + } + operand.operandCoding = -1; + operand.addressCoding = -1; + } + if (tokenPos < inputTokens.size()) + { + rv = ParseOperands2(t->next, operand, tokenPos + 1, t->level); + if (rv == AERR_NONE) + break; + } + } + tokenPos = last; + t++; + } + return rv; } -asmError x64Parser::ParseOperands(x64Token* tokenList, x64Operand& operand) -{ - asmError rv = ParseOperands2(tokenList, operand, 0, 0); - if (rv != AERR_NONE) - { - int n = tokenTable[","]; - std::vector fullList = inputTokens; - for (int i = 0; i < fullList.size();) - { - inputTokens.clear(); - while (i < fullList.size() && (fullList[i]->type != InputToken::TOKEN || fullList[i]->val->ival != n)) - inputTokens.push_back(fullList[i++]); - int j; - for (j = 0; j < sizeof(addressTable) / sizeof(addressTable[0]); j++) - { - if (ParseOperands2(addressTable[j], operand, 0, 0) == AERR_NONE) - break; - } - if (j == sizeof(addressTable) / sizeof(addressTable[0])) - { - inputTokens = fullList; - return AERR_OPERAND; - } - if (i < fullList.size()) - { - i++; - if (i == fullList.size()) - { - inputTokens = fullList; - return AERR_SYNTAX; - } - } - } - inputTokens = fullList; - return AERR_BADCOMBINATIONOFOPERANDS; - } - return rv; +asmError x64Parser::ParseOperands(x64Token *tokenList, x64Operand &operand) +{ + asmError rv = ParseOperands2(tokenList, operand, 0, 0); + if (rv != AERR_NONE) + { + int n = tokenTable[","]; + std::vectorfullList = inputTokens; + for (int i = 0; i < fullList.size();) + { + inputTokens.clear(); + while (i < fullList.size() && (fullList[i]->type != InputToken::TOKEN || fullList[i]->val->ival != n)) + inputTokens.push_back(fullList[i++]); + int j; + for (j = 0; j < sizeof(addressTable) / sizeof(addressTable[0]); j++) + { + if (ParseOperands2(addressTable[j], operand, 0, 0) == AERR_NONE) + break; + } + if (j == sizeof(addressTable) / sizeof(addressTable[0])) + { + inputTokens= fullList; + return AERR_OPERAND; + } + if (i < fullList.size()) + { + i++; + if (i == fullList.size()) + { + inputTokens= fullList; + return AERR_SYNTAX; + } + } + } + inputTokens= fullList; + return AERR_BADCOMBINATIONOFOPERANDS; + } + return rv; } -bool x64Parser::CheckCoding(x64Operand& operand, Coding* coding) -{ - while (coding->type != Coding::eot) - { - if (coding->type & Coding::stateFunc) - { - Coding* c = (this->*stateFuncs[coding->val])(); - if (!CheckCoding(operand, c)) - return false; - } - else if (coding->type & Coding::native) - { - if (operand.addressCoding == -1) - return false; - if (!CheckCoding(operand, Codings[operand.addressCoding])) - return false; - } - else if (coding->type & Coding::indirect) - { - if (!operand.values[coding->val]) - { - if (!(coding->type & Coding::optional)) - { - return false; - } - } - else - { - if (!CheckCoding(operand, operand.values[coding->val])) - return false; - } - } - else if (coding->type & Coding::illegal) - { - return false; - } - coding++; - } - return true; -} -bool x64Parser::ProcessCoding(x64Operand& operand, Coding* coding, int field, int bits, int* arr, char* bitcounts, char* func, - int& index) -{ - int acc = 0, binary = 0; - while (coding->type != Coding::eot) - { - if (coding->type & Coding::bitSpecified) - bits = coding->bits; - if (coding->type & Coding::valSpecified) - { - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = coding->val; - } - else if (coding->type & Coding::reg) - { - int n = coding->val; - if (field != -1) - n = registerValues[n][field]; - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = n; - } - else if (coding->type & Coding::stateFunc) - { - Coding* c = (this->*stateFuncs[coding->val])(); - int index1 = index; - if (!ProcessCoding(operand, c, coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - else if (coding->type & Coding::stateVar) - { - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = stateVars[coding->val]; - } - else if (coding->type & Coding::number) - { - int n = coding->val; - auto it = operands.begin(); - for (int i = 0; i < n; i++) - { - ++it; - } - (*it)->used = true; - n = 0; - for (int i = 0; i < index; i++) - if (!func[i]) - n += bitcounts[i]; - (*it)->pos = n; - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = (*it)->node->ival; - } - else if (coding->type & Coding::native) - { - if (operand.addressCoding == -1) - return false; - int index1 = index; - if (!ProcessCoding(operand, Codings[operand.addressCoding], coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - else if (coding->type & Coding::indirect) - { - if (!operand.values[coding->val]) - { - if (!(coding->type & Coding::optional)) - { - return false; - } - } - else - { - int index1 = index; - if (!ProcessCoding(operand, operand.values[coding->val], coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - } - else if (coding->type & Coding::illegal) - { - return false; - } - else - { - return false; - } - coding++; - } - return true; -} -bool x64Parser::ProcessCoding(x64Operand& operand, Coding* coding) -{ - int arr[1000]; - char bitcount[1000]; - char func[1000]; - int index = 0; - if (coding->type == Coding::eot) - return true; - int defaultBits = 8; - bool rv = ProcessCoding(operand, coding, -1, defaultBits, arr, bitcount, func, index); - if (rv) - { - for (int i = 0; i < index; i++) - { - if (func[i]) - arr[i + 1] = DoMath(func[i], arr[i], arr[i + 1]); - else - bits.Add(arr[i], bitcount[i]); - } - } - return rv; +bool x64Parser::CheckCoding(x64Operand &operand,Coding *coding) +{ + while (coding->type != Coding::eot) + { + if (coding->type & Coding::stateFunc) + { + Coding *c = (this->*stateFuncs[coding->val])(); + if (!CheckCoding(operand, c)) + return false; + } + else if (coding->type & Coding::native) + { + if (operand.addressCoding == -1) + return false; + if (!CheckCoding(operand, Codings[operand.addressCoding])) + return false; + } + else if (coding->type & Coding::indirect) + { + if (!operand.values[coding->val]) + { + if (!(coding->type & Coding::optional)) + { + return false; + } + } + else + { + if (!CheckCoding(operand, operand.values[coding->val])) + return false; + } + } + else if (coding->type & Coding::illegal) + { + return false; + } + coding++; + } + return true; +} +bool x64Parser::ProcessCoding(x64Operand &operand, Coding *coding, int field, int bits, int* arr, char* bitcounts, char *func, int &index) +{ + int acc = 0, binary = 0; + while (coding->type != Coding::eot) + { + if (coding->type & Coding::bitSpecified) + bits = coding->bits; + if (coding->type & Coding::valSpecified) + { + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = coding->val; + } + else if (coding->type & Coding::reg) + { + int n = coding->val; + if (field != -1) + n = registerValues[n][field]; + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = n; + } + else if (coding->type & Coding::stateFunc) + { + Coding *c = (this->*stateFuncs[coding->val])(); + int index1 = index; + if (!ProcessCoding(operand, c, coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + else if (coding->type & Coding::stateVar) + { + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = stateVars[coding->val]; + } + else if (coding->type & Coding::number) + { + int n = coding->val; + auto it = operands.begin(); + for (int i = 0; i < n; i++) + { + ++it; + } + (*it)->used = true; + n = 0; + for (int i = 0; i < index; i++) + if (!func[i]) + n += bitcounts[i]; + (*it)->pos = n; + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = (*it)->node->ival; + } + else if (coding->type & Coding::native) + { + if (operand.addressCoding == -1) + return false; + int index1 = index; + if (!ProcessCoding(operand, Codings[operand.addressCoding], coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + else if (coding->type & Coding::indirect) + { + if (!operand.values[coding->val]) + { + if (!(coding->type & Coding::optional)) + { + return false; + } + } + else + { + int index1 = index; + if (!ProcessCoding(operand, operand.values[coding->val], coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + } + else if (coding->type & Coding::illegal) + { + return false; + } + else + { + return false; + } + coding++; + } + return true; +} +bool x64Parser::ProcessCoding(x64Operand &operand, Coding *coding) +{ + int arr[1000]; + char bitcount[1000]; + char func[1000]; + int index = 0; + if (coding->type == Coding::eot) + return true; + int defaultBits = 8; + bool rv = ProcessCoding(operand, coding, -1, defaultBits, arr, bitcount, func, index); + if (rv) + { + for (int i = 0; i < index; i++) + { + if (func[i]) + arr[i + 1] = DoMath(func[i], arr[i], arr[i + 1]); + else + bits.Add(arr[i], bitcount[i]); + } + } + return rv; } asmError x64Parser::DispatchOpcode(int opcode) { - bool rv = true; - if (opcode == -1) - { - x64Operand operand; - for (auto& a : prefixes) - rv &= ProcessCoding(operand, prefixCodings[a]); - if (!rv) - return AERR_UNKNOWNOPCODE; - } - else - { - x64Operand operand; - operand.opcode = opcode; - auto err = (this->*DispatchTable[opcode])(operand); - if (err == AERR_NONE) - { - for (auto& a : prefixes) - rv &= ProcessCoding(operand, prefixCodings[a]); - if (rv) - { - if (operand.operandCoding != -1) - rv = ProcessCoding(operand, Codings[operand.operandCoding]); - else if (operand.addressCoding != -1) - rv = ProcessCoding(operand, Codings[operand.addressCoding]); - else - rv = false; - if (!rv) - return AERR_INVALIDINSTRUCTIONUSE; - } - } - else - { - return err; - } - } - return AERR_NONE; + bool rv=true; + if (opcode == -1) + { + x64Operand operand; + for (auto& a : prefixes) + rv &= ProcessCoding(operand, prefixCodings[a]); + if (!rv) + return AERR_UNKNOWNOPCODE; + } + else + { + x64Operand operand; + operand.opcode = opcode; + auto err = (this->*DispatchTable[opcode])(operand); + if (err == AERR_NONE) + { + for (auto& a : prefixes) + rv &= ProcessCoding(operand, prefixCodings[a]); + if (rv) + { + if (operand.operandCoding != -1) + rv = ProcessCoding(operand, Codings[operand.operandCoding]); + else if (operand.addressCoding != -1) + rv = ProcessCoding(operand, Codings[operand.addressCoding]); + else rv = false; + if (!rv) + return AERR_INVALIDINSTRUCTIONUSE; + } + } + else + { + return err; + } + } + return AERR_NONE; } diff --git a/src/oasm/x64Parser.h b/src/oasm/x64Parser.h index fac1e08a9..987b757d1 100644 --- a/src/oasm/x64Parser.h +++ b/src/oasm/x64Parser.h @@ -6,8293 +6,8293 @@ class Section; class AsmFile; -class x64Parser : public InstructionParser -{ - public: - x64Parser() { Init(); } - void Setprocessorbits(int v) { stateVars[0] = v; } - int Getprocessorbits() { return stateVars[0]; } - virtual void Setup(Section* sect); - virtual void Init(); - virtual bool ParseSection(AsmFile* fil, Section* sect); - virtual bool ParseDirective(AsmFile* fil, Section* sect); - virtual bool IsBigEndian() { return 0; } +class x64Parser : public InstructionParser +{ +public: + x64Parser() { Init(); } + void Setprocessorbits(int v) { stateVars[0] = v; } + int Getprocessorbits() { return stateVars[0]; } + virtual void Setup(Section *sect); + virtual void Init(); + virtual bool ParseSection(AsmFile *fil, Section *sect); + virtual bool ParseDirective(AsmFile *fil, Section *sect); + virtual bool IsBigEndian() { return 0; } - protected: - bool ParseAddresses(x64Operand& operand, int addrClass, int& tokenPos); - asmError ParseOperands2(x64Token* tokenList, x64Operand& operand, int tokenPos, int level); - asmError ParseOperands(x64Token* tokenList, x64Operand& operand); - bool ProcessCoding(x64Operand& operand, Coding* coding); - bool ProcessCoding(x64Operand& operand, Coding* coding, int field, int bits, int* arr, char* bitcounts, char* func, int& index); - bool CheckCoding(x64Operand& operand, Coding* coding); - bool MatchesToken(int token, int tokenPos); - bool MatchesRegister(int reg, int tokenPos); - bool MatchesRegisterClass(int cclass, int tokenPos); - int DoMath(char op, int left, int right); - virtual asmError DispatchOpcode(int opcode); +protected: + bool ParseAddresses(x64Operand &operand, int addrClass, int &tokenPos); + asmError ParseOperands2(x64Token *tokenList, x64Operand &operand, int tokenPos, int level); + asmError ParseOperands(x64Token *tokenList, x64Operand &operand); + bool ProcessCoding(x64Operand &operand, Coding *coding); + bool ProcessCoding(x64Operand &operand, Coding *coding, int field, int bits, int* arr, char* bitcounts, char *func, int &index); + bool CheckCoding(x64Operand &operand,Coding *coding); + bool MatchesToken(int token, int tokenPos); + bool MatchesRegister(int reg, int tokenPos); + bool MatchesRegisterClass(int cclass, int tokenPos); + int DoMath(char op, int left, int right); + virtual asmError DispatchOpcode(int opcode); - typedef asmError (x64Parser::*DispatchType)(x64Operand&); - static DispatchType DispatchTable[]; + typedef asmError (x64Parser::*DispatchType)(x64Operand &); + static DispatchType DispatchTable[]; - static x64Token* addressTable[]; + static x64Token *addressTable[]; - typedef Coding* (x64Parser::*StateFuncDispatchType)(); - static StateFuncDispatchType stateFuncs[]; - Coding* StateFunc1(); - Coding* StateFunc2(); - Coding* StateFunc3(); - Coding* StateFunc4(); - Coding* StateFunc5(); - Coding* StateFunc6(); - Coding* StateFunc7(); - Coding* StateFunc8(); - Coding* StateFunc9(); + typedef Coding * (x64Parser::*StateFuncDispatchType)(); + static StateFuncDispatchType stateFuncs[]; + Coding *StateFunc1(); + Coding *StateFunc2(); + Coding *StateFunc3(); + Coding *StateFunc4(); + Coding *StateFunc5(); + Coding *StateFunc6(); + Coding *StateFunc7(); + Coding *StateFunc8(); + Coding *StateFunc9(); - private: - int stateVars[1]; +private: + int stateVars[1]; - static Coding stateCoding_eot[]; - static Coding stateCoding1_1[]; - static Coding stateCoding1_2[]; - static Coding stateCoding2_1[]; - static Coding stateCoding2_2[]; - static Coding stateCoding3_1[]; - static Coding stateCoding4_1[]; - static Coding stateCoding4_2[]; - static Coding stateCoding5_1[]; - static Coding stateCoding5_2[]; - static Coding stateCoding6_1[]; - static Coding stateCoding7_1[]; - static Coding stateCoding7_2[]; - static Coding stateCoding8_1[]; - static Coding stateCoding8_2[]; - static Coding stateCoding9_1[]; + static Coding stateCoding_eot[]; + static Coding stateCoding1_1[]; + static Coding stateCoding1_2[]; + static Coding stateCoding2_1[]; + static Coding stateCoding2_2[]; + static Coding stateCoding3_1[]; + static Coding stateCoding4_1[]; + static Coding stateCoding4_2[]; + static Coding stateCoding5_1[]; + static Coding stateCoding5_2[]; + static Coding stateCoding6_1[]; + static Coding stateCoding7_1[]; + static Coding stateCoding7_2[]; + static Coding stateCoding8_1[]; + static Coding stateCoding8_2[]; + static Coding stateCoding9_1[]; - typedef bool (x64Parser::*NumberDispatchType)(int tokenPos); - static NumberDispatchType numberFuncs[]; - bool Number1(int tokenPos); - bool Number2(int tokenPos); - bool Number3(int tokenPos); - bool Number4(int tokenPos); - bool Number5(int tokenPos); - bool Number6(int tokenPos); - bool Number7(int tokenPos); - bool Number8(int tokenPos); - bool Number9(int tokenPos); - bool Number10(int tokenPos); - bool Number11(int tokenPos); - bool Number12(int tokenPos); - bool Number13(int tokenPos); - bool Number14(int tokenPos); - bool Number15(int tokenPos); - bool Number16(int tokenPos); - bool Number17(int tokenPos); - bool Number18(int tokenPos); - bool Number19(int tokenPos); - bool Number20(int tokenPos); - bool Number21(int tokenPos); - bool Number22(int tokenPos); + typedef bool (x64Parser::*NumberDispatchType)(int tokenPos); + static NumberDispatchType numberFuncs[]; + bool Number1(int tokenPos); + bool Number2(int tokenPos); + bool Number3(int tokenPos); + bool Number4(int tokenPos); + bool Number5(int tokenPos); + bool Number6(int tokenPos); + bool Number7(int tokenPos); + bool Number8(int tokenPos); + bool Number9(int tokenPos); + bool Number10(int tokenPos); + bool Number11(int tokenPos); + bool Number12(int tokenPos); + bool Number13(int tokenPos); + bool Number14(int tokenPos); + bool Number15(int tokenPos); + bool Number16(int tokenPos); + bool Number17(int tokenPos); + bool Number18(int tokenPos); + bool Number19(int tokenPos); + bool Number20(int tokenPos); + bool Number21(int tokenPos); + bool Number22(int tokenPos); - static unsigned char RegClassData1[]; - static unsigned char RegClassData2[]; - static unsigned char RegClassData3[]; - static unsigned char RegClassData4[]; - static unsigned char RegClassData5[]; - static unsigned char RegClassData6[]; - static unsigned char RegClassData7[]; - static unsigned char RegClassData8[]; - static unsigned char RegClassData9[]; - static unsigned char RegClassData10[]; - static unsigned char RegClassData11[]; - static unsigned char RegClassData12[]; - static unsigned char RegClassData13[]; + static unsigned char RegClassData1[]; + static unsigned char RegClassData2[]; + static unsigned char RegClassData3[]; + static unsigned char RegClassData4[]; + static unsigned char RegClassData5[]; + static unsigned char RegClassData6[]; + static unsigned char RegClassData7[]; + static unsigned char RegClassData8[]; + static unsigned char RegClassData9[]; + static unsigned char RegClassData10[]; + static unsigned char RegClassData11[]; + static unsigned char RegClassData12[]; + static unsigned char RegClassData13[]; - static unsigned char registerData17[]; - static unsigned char registerData13[]; - static unsigned char registerData6[]; - static unsigned char registerData9[]; - static unsigned char registerData22[]; - static unsigned char registerData23[]; - static unsigned char registerData21[]; - static unsigned char registerData1[]; - static unsigned char registerData4[]; - static unsigned char registerData16[]; - static unsigned char registerData7[]; - static unsigned char registerData10[]; - static unsigned char registerData3[]; - static unsigned char registerData12[]; - static unsigned char registerData5[]; - static unsigned char registerData8[]; - static unsigned char registerData11[]; - static unsigned char registerData2[]; - static unsigned char registerData15[]; - static unsigned char registerData19[]; - static unsigned char registerData18[]; - static unsigned char registerData20[]; - static unsigned char registerData14[]; - static unsigned char registerData24[]; - static unsigned char* registerDataIndirect[]; + static unsigned char registerData17[]; + static unsigned char registerData13[]; + static unsigned char registerData6[]; + static unsigned char registerData9[]; + static unsigned char registerData22[]; + static unsigned char registerData23[]; + static unsigned char registerData21[]; + static unsigned char registerData1[]; + static unsigned char registerData4[]; + static unsigned char registerData16[]; + static unsigned char registerData7[]; + static unsigned char registerData10[]; + static unsigned char registerData3[]; + static unsigned char registerData12[]; + static unsigned char registerData5[]; + static unsigned char registerData8[]; + static unsigned char registerData11[]; + static unsigned char registerData2[]; + static unsigned char registerData15[]; + static unsigned char registerData19[]; + static unsigned char registerData18[]; + static unsigned char registerData20[]; + static unsigned char registerData14[]; + static unsigned char registerData24[]; + static unsigned char *registerDataIndirect[]; - static int registerValues[][8]; + static int registerValues[][8]; - static x64Token tokenBranches1[]; - static x64Token tokenBranches2[]; - void TokenFunc3(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3[]; - void TokenFunc4(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6[]; - static x64Token tokenBranches7[]; - void TokenFunc8(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8[]; - void TokenFunc9(x64Operand& operand, int tokenPos); - static x64Token tokenBranches11[]; - static x64Token tokenBranches12[]; - void TokenFunc13(x64Operand& operand, int tokenPos); - static x64Token tokenBranches13[]; - void TokenFunc14(x64Operand& operand, int tokenPos); - void TokenFunc16(x64Operand& operand, int tokenPos); - static x64Token tokenBranches16[]; - static x64Token tokenBranches17[]; - void TokenFunc18(x64Operand& operand, int tokenPos); - static x64Token tokenBranches18[]; - void TokenFunc19(x64Operand& operand, int tokenPos); - static x64Token tokenBranches21[]; - static x64Token tokenBranches22[]; - void TokenFunc23(x64Operand& operand, int tokenPos); - static x64Token tokenBranches23[]; - void TokenFunc24(x64Operand& operand, int tokenPos); - static x64Token tokenBranches26[]; - static x64Token tokenBranches27[]; - void TokenFunc28(x64Operand& operand, int tokenPos); - static x64Token tokenBranches28[]; - void TokenFunc29(x64Operand& operand, int tokenPos); - static x64Token tokenBranches33[]; - static x64Token tokenBranches34[]; - void TokenFunc35(x64Operand& operand, int tokenPos); - static x64Token tokenBranches35[]; - void TokenFunc36(x64Operand& operand, int tokenPos); - static x64Token tokenBranches40[]; - static x64Token tokenBranches41[]; - void TokenFunc42(x64Operand& operand, int tokenPos); - static x64Token tokenBranches42[]; - void TokenFunc43(x64Operand& operand, int tokenPos); - static x64Token tokenBranches47[]; - static x64Token tokenBranches48[]; - void TokenFunc49(x64Operand& operand, int tokenPos); - static x64Token tokenBranches49[]; - void TokenFunc50(x64Operand& operand, int tokenPos); - static x64Token tokenBranches54[]; - static x64Token tokenBranches55[]; - void TokenFunc56(x64Operand& operand, int tokenPos); - static x64Token tokenBranches56[]; - void TokenFunc57(x64Operand& operand, int tokenPos); - static x64Token tokenBranches61[]; - static x64Token tokenBranches62[]; - void TokenFunc63(x64Operand& operand, int tokenPos); - static x64Token tokenBranches63[]; - void TokenFunc64(x64Operand& operand, int tokenPos); - static x64Token tokenBranches68[]; - static x64Token tokenBranches69[]; - void TokenFunc70(x64Operand& operand, int tokenPos); - static x64Token tokenBranches70[]; - void TokenFunc71(x64Operand& operand, int tokenPos); - void TokenFunc73(x64Operand& operand, int tokenPos); - static x64Token tokenBranches73[]; - void TokenFunc74(x64Operand& operand, int tokenPos); - void TokenFunc78(x64Operand& operand, int tokenPos); - static x64Token tokenBranches78[]; - void TokenFunc79(x64Operand& operand, int tokenPos); - void TokenFunc83(x64Operand& operand, int tokenPos); - static x64Token tokenBranches83[]; - void TokenFunc84(x64Operand& operand, int tokenPos); - void TokenFunc88(x64Operand& operand, int tokenPos); - static x64Token tokenBranches88[]; - void TokenFunc89(x64Operand& operand, int tokenPos); - void TokenFunc92(x64Operand& operand, int tokenPos); - void TokenFunc97(x64Operand& operand, int tokenPos); - void TokenFunc102(x64Operand& operand, int tokenPos); - void TokenFunc107(x64Operand& operand, int tokenPos); - void TokenFunc110(x64Operand& operand, int tokenPos); - void TokenFunc115(x64Operand& operand, int tokenPos); - void TokenFunc120(x64Operand& operand, int tokenPos); - void TokenFunc125(x64Operand& operand, int tokenPos); - void TokenFunc129(x64Operand& operand, int tokenPos); - static x64Token tokenBranches129[]; - void TokenFunc130(x64Operand& operand, int tokenPos); - void TokenFunc136(x64Operand& operand, int tokenPos); - static x64Token tokenBranches136[]; - void TokenFunc137(x64Operand& operand, int tokenPos); - void TokenFunc143(x64Operand& operand, int tokenPos); - static x64Token tokenBranches143[]; - void TokenFunc144(x64Operand& operand, int tokenPos); - void TokenFunc150(x64Operand& operand, int tokenPos); - static x64Token tokenBranches150[]; - void TokenFunc151(x64Operand& operand, int tokenPos); - void TokenFunc155(x64Operand& operand, int tokenPos); - static x64Token tokenBranches155[]; - void TokenFunc156(x64Operand& operand, int tokenPos); - void TokenFunc162(x64Operand& operand, int tokenPos); - static x64Token tokenBranches162[]; - void TokenFunc163(x64Operand& operand, int tokenPos); - void TokenFunc169(x64Operand& operand, int tokenPos); - static x64Token tokenBranches169[]; - void TokenFunc170(x64Operand& operand, int tokenPos); - void TokenFunc176(x64Operand& operand, int tokenPos); - static x64Token tokenBranches176[]; - void TokenFunc177(x64Operand& operand, int tokenPos); - static x64Token tokenBranches182[]; - void TokenFunc183(x64Operand& operand, int tokenPos); - static x64Token tokenBranches183[]; - void TokenFunc184(x64Operand& operand, int tokenPos); - static x64Token tokenBranches189[]; - void TokenFunc190(x64Operand& operand, int tokenPos); - static x64Token tokenBranches190[]; - void TokenFunc191(x64Operand& operand, int tokenPos); - static x64Token tokenBranches198[]; - void TokenFunc199(x64Operand& operand, int tokenPos); - static x64Token tokenBranches199[]; - void TokenFunc200(x64Operand& operand, int tokenPos); - static x64Token tokenBranches207[]; - void TokenFunc208(x64Operand& operand, int tokenPos); - static x64Token tokenBranches208[]; - void TokenFunc209(x64Operand& operand, int tokenPos); - static x64Token tokenBranches216[]; - void TokenFunc217(x64Operand& operand, int tokenPos); - static x64Token tokenBranches217[]; - void TokenFunc218(x64Operand& operand, int tokenPos); - static x64Token tokenBranches225[]; - void TokenFunc226(x64Operand& operand, int tokenPos); - static x64Token tokenBranches226[]; - void TokenFunc227(x64Operand& operand, int tokenPos); - static x64Token tokenBranches234[]; - void TokenFunc235(x64Operand& operand, int tokenPos); - static x64Token tokenBranches235[]; - void TokenFunc236(x64Operand& operand, int tokenPos); - static x64Token tokenBranches243[]; - void TokenFunc244(x64Operand& operand, int tokenPos); - static x64Token tokenBranches244[]; - void TokenFunc245(x64Operand& operand, int tokenPos); - static x64Token tokenBranches248[]; - void TokenFunc249(x64Operand& operand, int tokenPos); - static x64Token tokenBranches249[]; - void TokenFunc250(x64Operand& operand, int tokenPos); - static x64Token tokenBranches255[]; - void TokenFunc256(x64Operand& operand, int tokenPos); - static x64Token tokenBranches256[]; - void TokenFunc257(x64Operand& operand, int tokenPos); - static x64Token tokenBranches262[]; - void TokenFunc263(x64Operand& operand, int tokenPos); - static x64Token tokenBranches263[]; - void TokenFunc264(x64Operand& operand, int tokenPos); - static x64Token tokenBranches269[]; - void TokenFunc270(x64Operand& operand, int tokenPos); - static x64Token tokenBranches270[]; - void TokenFunc271(x64Operand& operand, int tokenPos); - void TokenFunc275(x64Operand& operand, int tokenPos); - static x64Token tokenBranches275[]; - void TokenFunc276(x64Operand& operand, int tokenPos); - void TokenFunc282(x64Operand& operand, int tokenPos); - static x64Token tokenBranches282[]; - void TokenFunc283(x64Operand& operand, int tokenPos); - void TokenFunc289(x64Operand& operand, int tokenPos); - static x64Token tokenBranches289[]; - void TokenFunc290(x64Operand& operand, int tokenPos); - void TokenFunc296(x64Operand& operand, int tokenPos); - static x64Token tokenBranches296[]; - void TokenFunc297(x64Operand& operand, int tokenPos); - void TokenFunc301(x64Operand& operand, int tokenPos); - static x64Token tokenBranches301[]; - void TokenFunc302(x64Operand& operand, int tokenPos); - void TokenFunc308(x64Operand& operand, int tokenPos); - static x64Token tokenBranches308[]; - void TokenFunc309(x64Operand& operand, int tokenPos); - void TokenFunc315(x64Operand& operand, int tokenPos); - static x64Token tokenBranches315[]; - void TokenFunc316(x64Operand& operand, int tokenPos); - void TokenFunc322(x64Operand& operand, int tokenPos); - static x64Token tokenBranches322[]; - void TokenFunc323(x64Operand& operand, int tokenPos); - void TokenFunc329(x64Operand& operand, int tokenPos); - static x64Token tokenBranches329[]; - void TokenFunc330(x64Operand& operand, int tokenPos); - void TokenFunc336(x64Operand& operand, int tokenPos); - static x64Token tokenBranches336[]; - void TokenFunc337(x64Operand& operand, int tokenPos); - void TokenFunc345(x64Operand& operand, int tokenPos); - static x64Token tokenBranches345[]; - void TokenFunc346(x64Operand& operand, int tokenPos); - void TokenFunc354(x64Operand& operand, int tokenPos); - static x64Token tokenBranches354[]; - void TokenFunc355(x64Operand& operand, int tokenPos); - void TokenFunc363(x64Operand& operand, int tokenPos); - static x64Token tokenBranches363[]; - void TokenFunc364(x64Operand& operand, int tokenPos); - void TokenFunc372(x64Operand& operand, int tokenPos); - static x64Token tokenBranches372[]; - void TokenFunc373(x64Operand& operand, int tokenPos); - void TokenFunc381(x64Operand& operand, int tokenPos); - static x64Token tokenBranches381[]; - void TokenFunc382(x64Operand& operand, int tokenPos); - void TokenFunc390(x64Operand& operand, int tokenPos); - static x64Token tokenBranches390[]; - void TokenFunc391(x64Operand& operand, int tokenPos); - void TokenFunc395(x64Operand& operand, int tokenPos); - static x64Token tokenBranches395[]; - void TokenFunc396(x64Operand& operand, int tokenPos); - void TokenFunc402(x64Operand& operand, int tokenPos); - static x64Token tokenBranches402[]; - void TokenFunc403(x64Operand& operand, int tokenPos); - void TokenFunc409(x64Operand& operand, int tokenPos); - static x64Token tokenBranches409[]; - void TokenFunc410(x64Operand& operand, int tokenPos); - void TokenFunc416(x64Operand& operand, int tokenPos); - static x64Token tokenBranches416[]; - void TokenFunc417(x64Operand& operand, int tokenPos); - void TokenFunc421(x64Operand& operand, int tokenPos); - static x64Token tokenBranches421[]; - void TokenFunc422(x64Operand& operand, int tokenPos); - void TokenFunc428(x64Operand& operand, int tokenPos); - static x64Token tokenBranches428[]; - void TokenFunc429(x64Operand& operand, int tokenPos); - void TokenFunc435(x64Operand& operand, int tokenPos); - static x64Token tokenBranches435[]; - void TokenFunc436(x64Operand& operand, int tokenPos); - void TokenFunc442(x64Operand& operand, int tokenPos); - static x64Token tokenBranches442[]; - void TokenFunc443(x64Operand& operand, int tokenPos); - void TokenFunc447(x64Operand& operand, int tokenPos); - static x64Token tokenBranches447[]; - void TokenFunc448(x64Operand& operand, int tokenPos); - void TokenFunc454(x64Operand& operand, int tokenPos); - static x64Token tokenBranches454[]; - void TokenFunc455(x64Operand& operand, int tokenPos); - void TokenFunc461(x64Operand& operand, int tokenPos); - static x64Token tokenBranches461[]; - void TokenFunc462(x64Operand& operand, int tokenPos); - void TokenFunc468(x64Operand& operand, int tokenPos); - static x64Token tokenBranches468[]; - void TokenFunc469(x64Operand& operand, int tokenPos); - static x64Token tokenBranches471[]; - void TokenFunc472(x64Operand& operand, int tokenPos); - static x64Token tokenBranches474[]; - void TokenFunc475(x64Operand& operand, int tokenPos); - static x64Token tokenBranches477[]; - void TokenFunc478(x64Operand& operand, int tokenPos); - void TokenFunc480(x64Operand& operand, int tokenPos); - static x64Token tokenBranches480[]; - void TokenFunc481(x64Operand& operand, int tokenPos); - static x64Token tokenBranches484[]; - static x64Token tokenBranches485[]; - void TokenFunc486(x64Operand& operand, int tokenPos); - static x64Token tokenBranches490[]; - void TokenFunc491(x64Operand& operand, int tokenPos); - static x64Token tokenBranches495[]; - void TokenFunc496(x64Operand& operand, int tokenPos); - static x64Token tokenBranches500[]; - void TokenFunc501(x64Operand& operand, int tokenPos); - static x64Token tokenBranches505[]; - void TokenFunc506(x64Operand& operand, int tokenPos); - static x64Token tokenBranches510[]; - void TokenFunc511(x64Operand& operand, int tokenPos); - static x64Token tokenBranches515[]; - void TokenFunc516(x64Operand& operand, int tokenPos); - static x64Token tokenBranches520[]; - void TokenFunc521(x64Operand& operand, int tokenPos); - void TokenFunc525(x64Operand& operand, int tokenPos); - static x64Token tokenBranches525[]; - void TokenFunc526(x64Operand& operand, int tokenPos); - void TokenFunc530(x64Operand& operand, int tokenPos); - static x64Token tokenBranches530[]; - void TokenFunc531(x64Operand& operand, int tokenPos); - static x64Token tokenBranches536[]; - static x64Token tokenBranches537[]; - void TokenFunc538(x64Operand& operand, int tokenPos); - static x64Token tokenBranches543[]; - static x64Token tokenBranches544[]; - void TokenFunc545(x64Operand& operand, int tokenPos); - void TokenFunc549(x64Operand& operand, int tokenPos); - static x64Token tokenBranches549[]; - void TokenFunc550(x64Operand& operand, int tokenPos); - static x64Token tokenBranches555[]; - static x64Token tokenBranches556[]; - void TokenFunc557(x64Operand& operand, int tokenPos); - void TokenFunc559(x64Operand& operand, int tokenPos); - static x64Token tokenBranches559[]; - void TokenFunc560(x64Operand& operand, int tokenPos); - void TokenFunc564(x64Operand& operand, int tokenPos); - static x64Token tokenBranches564[]; - void TokenFunc565(x64Operand& operand, int tokenPos); - void TokenFunc569(x64Operand& operand, int tokenPos); - static x64Token tokenBranches569[]; - void TokenFunc570(x64Operand& operand, int tokenPos); - void TokenFunc574(x64Operand& operand, int tokenPos); - static x64Token tokenBranches574[]; - void TokenFunc575(x64Operand& operand, int tokenPos); - static x64Token tokenBranches578[]; - void TokenFunc579(x64Operand& operand, int tokenPos); - static x64Token tokenBranches579[]; - void TokenFunc580(x64Operand& operand, int tokenPos); - static x64Token tokenBranches583[]; - void TokenFunc584(x64Operand& operand, int tokenPos); - static x64Token tokenBranches584[]; - void TokenFunc585(x64Operand& operand, int tokenPos); - static x64Token tokenBranches590[]; - void TokenFunc591(x64Operand& operand, int tokenPos); - static x64Token tokenBranches591[]; - void TokenFunc592(x64Operand& operand, int tokenPos); - static x64Token tokenBranches597[]; - void TokenFunc598(x64Operand& operand, int tokenPos); - static x64Token tokenBranches598[]; - void TokenFunc599(x64Operand& operand, int tokenPos); - static x64Token tokenBranches604[]; - void TokenFunc605(x64Operand& operand, int tokenPos); - static x64Token tokenBranches605[]; - void TokenFunc606(x64Operand& operand, int tokenPos); - static x64Token tokenBranches611[]; - void TokenFunc612(x64Operand& operand, int tokenPos); - static x64Token tokenBranches612[]; - void TokenFunc613(x64Operand& operand, int tokenPos); - static x64Token tokenBranches616[]; - void TokenFunc617(x64Operand& operand, int tokenPos); - static x64Token tokenBranches617[]; - void TokenFunc618(x64Operand& operand, int tokenPos); - void TokenFunc622(x64Operand& operand, int tokenPos); - static x64Token tokenBranches622[]; - void TokenFunc623(x64Operand& operand, int tokenPos); - static x64Token tokenBranches628[]; - void TokenFunc629(x64Operand& operand, int tokenPos); - static x64Token tokenBranches629[]; - void TokenFunc630(x64Operand& operand, int tokenPos); - static x64Token tokenBranches635[]; - void TokenFunc636(x64Operand& operand, int tokenPos); - static x64Token tokenBranches636[]; - void TokenFunc637(x64Operand& operand, int tokenPos); - void TokenFunc643(x64Operand& operand, int tokenPos); - static x64Token tokenBranches643[]; - void TokenFunc644(x64Operand& operand, int tokenPos); - static x64Token tokenBranches651[]; - void TokenFunc652(x64Operand& operand, int tokenPos); - static x64Token tokenBranches652[]; - void TokenFunc653(x64Operand& operand, int tokenPos); - void TokenFunc659(x64Operand& operand, int tokenPos); - static x64Token tokenBranches659[]; - void TokenFunc660(x64Operand& operand, int tokenPos); - static x64Token tokenBranches667[]; - void TokenFunc668(x64Operand& operand, int tokenPos); - static x64Token tokenBranches668[]; - void TokenFunc669(x64Operand& operand, int tokenPos); - void TokenFunc675(x64Operand& operand, int tokenPos); - static x64Token tokenBranches675[]; - void TokenFunc676(x64Operand& operand, int tokenPos); - static x64Token tokenBranches683[]; - void TokenFunc684(x64Operand& operand, int tokenPos); - static x64Token tokenBranches684[]; - void TokenFunc685(x64Operand& operand, int tokenPos); - void TokenFunc689(x64Operand& operand, int tokenPos); - static x64Token tokenBranches689[]; - void TokenFunc690(x64Operand& operand, int tokenPos); - void TokenFunc694(x64Operand& operand, int tokenPos); - static x64Token tokenBranches694[]; - void TokenFunc695(x64Operand& operand, int tokenPos); - void TokenFunc701(x64Operand& operand, int tokenPos); - static x64Token tokenBranches701[]; - void TokenFunc702(x64Operand& operand, int tokenPos); - void TokenFunc708(x64Operand& operand, int tokenPos); - static x64Token tokenBranches708[]; - void TokenFunc709(x64Operand& operand, int tokenPos); - void TokenFunc715(x64Operand& operand, int tokenPos); - static x64Token tokenBranches715[]; - void TokenFunc716(x64Operand& operand, int tokenPos); - void TokenFunc722(x64Operand& operand, int tokenPos); - static x64Token tokenBranches722[]; - void TokenFunc723(x64Operand& operand, int tokenPos); - static x64Token tokenBranches728[]; - void TokenFunc729(x64Operand& operand, int tokenPos); - static x64Token tokenBranches729[]; - void TokenFunc730(x64Operand& operand, int tokenPos); - static x64Token tokenBranches735[]; - void TokenFunc736(x64Operand& operand, int tokenPos); - static x64Token tokenBranches736[]; - void TokenFunc737(x64Operand& operand, int tokenPos); - void TokenFunc741(x64Operand& operand, int tokenPos); - static x64Token tokenBranches741[]; - void TokenFunc742(x64Operand& operand, int tokenPos); - void TokenFunc746(x64Operand& operand, int tokenPos); - static x64Token tokenBranches746[]; - void TokenFunc747(x64Operand& operand, int tokenPos); - void TokenFunc753(x64Operand& operand, int tokenPos); - static x64Token tokenBranches753[]; - void TokenFunc754(x64Operand& operand, int tokenPos); - void TokenFunc760(x64Operand& operand, int tokenPos); - static x64Token tokenBranches760[]; - void TokenFunc761(x64Operand& operand, int tokenPos); - void TokenFunc767(x64Operand& operand, int tokenPos); - static x64Token tokenBranches767[]; - void TokenFunc768(x64Operand& operand, int tokenPos); - void TokenFunc776(x64Operand& operand, int tokenPos); - static x64Token tokenBranches776[]; - void TokenFunc777(x64Operand& operand, int tokenPos); - void TokenFunc783(x64Operand& operand, int tokenPos); - static x64Token tokenBranches783[]; - void TokenFunc784(x64Operand& operand, int tokenPos); - void TokenFunc792(x64Operand& operand, int tokenPos); - static x64Token tokenBranches792[]; - void TokenFunc793(x64Operand& operand, int tokenPos); - void TokenFunc799(x64Operand& operand, int tokenPos); - static x64Token tokenBranches799[]; - void TokenFunc800(x64Operand& operand, int tokenPos); - void TokenFunc808(x64Operand& operand, int tokenPos); - static x64Token tokenBranches808[]; - void TokenFunc809(x64Operand& operand, int tokenPos); - void TokenFunc813(x64Operand& operand, int tokenPos); - static x64Token tokenBranches813[]; - void TokenFunc814(x64Operand& operand, int tokenPos); - void TokenFunc818(x64Operand& operand, int tokenPos); - static x64Token tokenBranches818[]; - void TokenFunc819(x64Operand& operand, int tokenPos); - void TokenFunc825(x64Operand& operand, int tokenPos); - static x64Token tokenBranches825[]; - void TokenFunc826(x64Operand& operand, int tokenPos); - void TokenFunc832(x64Operand& operand, int tokenPos); - static x64Token tokenBranches832[]; - void TokenFunc833(x64Operand& operand, int tokenPos); - void TokenFunc839(x64Operand& operand, int tokenPos); - static x64Token tokenBranches839[]; - void TokenFunc840(x64Operand& operand, int tokenPos); - void TokenFunc846(x64Operand& operand, int tokenPos); - static x64Token tokenBranches846[]; - void TokenFunc847(x64Operand& operand, int tokenPos); - void TokenFunc853(x64Operand& operand, int tokenPos); - static x64Token tokenBranches853[]; - void TokenFunc854(x64Operand& operand, int tokenPos); - void TokenFunc860(x64Operand& operand, int tokenPos); - static x64Token tokenBranches860[]; - void TokenFunc861(x64Operand& operand, int tokenPos); - void TokenFunc865(x64Operand& operand, int tokenPos); - static x64Token tokenBranches865[]; - void TokenFunc866(x64Operand& operand, int tokenPos); - void TokenFunc870(x64Operand& operand, int tokenPos); - static x64Token tokenBranches870[]; - void TokenFunc871(x64Operand& operand, int tokenPos); - void TokenFunc877(x64Operand& operand, int tokenPos); - static x64Token tokenBranches877[]; - void TokenFunc878(x64Operand& operand, int tokenPos); - void TokenFunc884(x64Operand& operand, int tokenPos); - static x64Token tokenBranches884[]; - void TokenFunc885(x64Operand& operand, int tokenPos); - void TokenFunc891(x64Operand& operand, int tokenPos); - static x64Token tokenBranches891[]; - void TokenFunc892(x64Operand& operand, int tokenPos); - void TokenFunc900(x64Operand& operand, int tokenPos); - static x64Token tokenBranches900[]; - void TokenFunc901(x64Operand& operand, int tokenPos); - void TokenFunc907(x64Operand& operand, int tokenPos); - static x64Token tokenBranches907[]; - void TokenFunc908(x64Operand& operand, int tokenPos); - void TokenFunc916(x64Operand& operand, int tokenPos); - static x64Token tokenBranches916[]; - void TokenFunc917(x64Operand& operand, int tokenPos); - void TokenFunc925(x64Operand& operand, int tokenPos); - static x64Token tokenBranches925[]; - void TokenFunc926(x64Operand& operand, int tokenPos); - void TokenFunc932(x64Operand& operand, int tokenPos); - static x64Token tokenBranches932[]; - void TokenFunc933(x64Operand& operand, int tokenPos); - static x64Token tokenBranches936[]; - void TokenFunc937(x64Operand& operand, int tokenPos); - static x64Token tokenBranches937[]; - void TokenFunc938(x64Operand& operand, int tokenPos); - static x64Token tokenBranches943[]; - void TokenFunc944(x64Operand& operand, int tokenPos); - static x64Token tokenBranches944[]; - void TokenFunc945(x64Operand& operand, int tokenPos); - void TokenFunc951(x64Operand& operand, int tokenPos); - static x64Token tokenBranches951[]; - void TokenFunc952(x64Operand& operand, int tokenPos); - void TokenFunc958(x64Operand& operand, int tokenPos); - static x64Token tokenBranches958[]; - void TokenFunc959(x64Operand& operand, int tokenPos); - static x64Token tokenBranches964[]; - void TokenFunc965(x64Operand& operand, int tokenPos); - static x64Token tokenBranches965[]; - void TokenFunc966(x64Operand& operand, int tokenPos); - static x64Token tokenBranches973[]; - void TokenFunc974(x64Operand& operand, int tokenPos); - static x64Token tokenBranches974[]; - void TokenFunc975(x64Operand& operand, int tokenPos); - void TokenFunc983(x64Operand& operand, int tokenPos); - static x64Token tokenBranches983[]; - void TokenFunc984(x64Operand& operand, int tokenPos); - void TokenFunc992(x64Operand& operand, int tokenPos); - static x64Token tokenBranches992[]; - void TokenFunc993(x64Operand& operand, int tokenPos); - static x64Token tokenBranches998[]; - void TokenFunc999(x64Operand& operand, int tokenPos); - static x64Token tokenBranches999[]; - void TokenFunc1000(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1007[]; - void TokenFunc1008(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1008[]; - void TokenFunc1009(x64Operand& operand, int tokenPos); - void TokenFunc1017(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1017[]; - void TokenFunc1018(x64Operand& operand, int tokenPos); - void TokenFunc1026(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1026[]; - void TokenFunc1027(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1032[]; - void TokenFunc1033(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1033[]; - void TokenFunc1034(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1041[]; - void TokenFunc1042(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1042[]; - void TokenFunc1043(x64Operand& operand, int tokenPos); - void TokenFunc1051(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1051[]; - void TokenFunc1052(x64Operand& operand, int tokenPos); - void TokenFunc1060(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1060[]; - void TokenFunc1061(x64Operand& operand, int tokenPos); - void TokenFunc1065(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1065[]; - void TokenFunc1066(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1071[]; - void TokenFunc1072(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1072[]; - void TokenFunc1073(x64Operand& operand, int tokenPos); - void TokenFunc1079(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1079[]; - void TokenFunc1080(x64Operand& operand, int tokenPos); - void TokenFunc1086(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1086[]; - void TokenFunc1087(x64Operand& operand, int tokenPos); - void TokenFunc1093(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1093[]; - void TokenFunc1094(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1101[]; - void TokenFunc1102(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1102[]; - void TokenFunc1103(x64Operand& operand, int tokenPos); - void TokenFunc1111(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1111[]; - void TokenFunc1112(x64Operand& operand, int tokenPos); - void TokenFunc1120(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1120[]; - void TokenFunc1121(x64Operand& operand, int tokenPos); - void TokenFunc1127(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1127[]; - void TokenFunc1128(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1135[]; - void TokenFunc1136(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1136[]; - void TokenFunc1137(x64Operand& operand, int tokenPos); - void TokenFunc1145(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1145[]; - void TokenFunc1146(x64Operand& operand, int tokenPos); - void TokenFunc1154(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1154[]; - void TokenFunc1155(x64Operand& operand, int tokenPos); - void TokenFunc1161(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1161[]; - void TokenFunc1162(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1169[]; - void TokenFunc1170(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1170[]; - void TokenFunc1171(x64Operand& operand, int tokenPos); - void TokenFunc1179(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1179[]; - void TokenFunc1180(x64Operand& operand, int tokenPos); - void TokenFunc1188(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1188[]; - void TokenFunc1189(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1192[]; - void TokenFunc1193(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1193[]; - void TokenFunc1194(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1199[]; - void TokenFunc1200(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1200[]; - void TokenFunc1201(x64Operand& operand, int tokenPos); - void TokenFunc1207(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1207[]; - void TokenFunc1208(x64Operand& operand, int tokenPos); - void TokenFunc1214(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1214[]; - void TokenFunc1215(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1219[]; - static x64Token tokenBranches1220[]; - void TokenFunc1221(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1221[]; - void TokenFunc1222(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1229[]; - void TokenFunc1230(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1230[]; - void TokenFunc1231(x64Operand& operand, int tokenPos); - void TokenFunc1239(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1239[]; - void TokenFunc1240(x64Operand& operand, int tokenPos); - void TokenFunc1248(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1248[]; - void TokenFunc1249(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1253[]; - static x64Token tokenBranches1254[]; - void TokenFunc1255(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1255[]; - void TokenFunc1256(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1263[]; - void TokenFunc1264(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1264[]; - void TokenFunc1265(x64Operand& operand, int tokenPos); - void TokenFunc1273(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1273[]; - void TokenFunc1274(x64Operand& operand, int tokenPos); - void TokenFunc1282(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1282[]; - void TokenFunc1283(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1288[]; - void TokenFunc1289(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1289[]; - void TokenFunc1290(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1297[]; - void TokenFunc1298(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1298[]; - void TokenFunc1299(x64Operand& operand, int tokenPos); - void TokenFunc1307(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1307[]; - void TokenFunc1308(x64Operand& operand, int tokenPos); - void TokenFunc1316(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1316[]; - void TokenFunc1317(x64Operand& operand, int tokenPos); - void TokenFunc1321(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1321[]; - void TokenFunc1322(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1327[]; - void TokenFunc1328(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1328[]; - void TokenFunc1329(x64Operand& operand, int tokenPos); - void TokenFunc1335(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1335[]; - void TokenFunc1336(x64Operand& operand, int tokenPos); - void TokenFunc1342(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1342[]; - void TokenFunc1343(x64Operand& operand, int tokenPos); - void TokenFunc1349(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1349[]; - void TokenFunc1350(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1357[]; - void TokenFunc1358(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1358[]; - void TokenFunc1359(x64Operand& operand, int tokenPos); - void TokenFunc1367(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1367[]; - void TokenFunc1368(x64Operand& operand, int tokenPos); - void TokenFunc1376(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1376[]; - void TokenFunc1377(x64Operand& operand, int tokenPos); - void TokenFunc1383(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1383[]; - void TokenFunc1384(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1391[]; - void TokenFunc1392(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1392[]; - void TokenFunc1393(x64Operand& operand, int tokenPos); - void TokenFunc1401(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1401[]; - void TokenFunc1402(x64Operand& operand, int tokenPos); - void TokenFunc1410(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1410[]; - void TokenFunc1411(x64Operand& operand, int tokenPos); - void TokenFunc1417(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1417[]; - void TokenFunc1418(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1425[]; - void TokenFunc1426(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1426[]; - void TokenFunc1427(x64Operand& operand, int tokenPos); - void TokenFunc1435(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1435[]; - void TokenFunc1436(x64Operand& operand, int tokenPos); - void TokenFunc1444(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1444[]; - void TokenFunc1445(x64Operand& operand, int tokenPos); - void TokenFunc1449(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1449[]; - void TokenFunc1450(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1455[]; - void TokenFunc1456(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1456[]; - void TokenFunc1457(x64Operand& operand, int tokenPos); - void TokenFunc1463(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1463[]; - void TokenFunc1464(x64Operand& operand, int tokenPos); - void TokenFunc1470(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1470[]; - void TokenFunc1471(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1478[]; - void TokenFunc1479(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1479[]; - void TokenFunc1480(x64Operand& operand, int tokenPos); - void TokenFunc1488(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1488[]; - void TokenFunc1489(x64Operand& operand, int tokenPos); - void TokenFunc1495(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1495[]; - void TokenFunc1496(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1503[]; - void TokenFunc1504(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1504[]; - void TokenFunc1505(x64Operand& operand, int tokenPos); - void TokenFunc1513(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1513[]; - void TokenFunc1514(x64Operand& operand, int tokenPos); - void TokenFunc1520(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1520[]; - void TokenFunc1521(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1528[]; - void TokenFunc1529(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1529[]; - void TokenFunc1530(x64Operand& operand, int tokenPos); - void TokenFunc1538(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1538[]; - void TokenFunc1539(x64Operand& operand, int tokenPos); - void TokenFunc1543(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1543[]; - void TokenFunc1544(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1549[]; - void TokenFunc1550(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1550[]; - void TokenFunc1551(x64Operand& operand, int tokenPos); - void TokenFunc1557(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1557[]; - void TokenFunc1558(x64Operand& operand, int tokenPos); - void TokenFunc1564(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1564[]; - void TokenFunc1565(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1572[]; - void TokenFunc1573(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1573[]; - void TokenFunc1574(x64Operand& operand, int tokenPos); - void TokenFunc1582(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1582[]; - void TokenFunc1583(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1586[]; - void TokenFunc1587(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1587[]; - void TokenFunc1588(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1593[]; - void TokenFunc1594(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1594[]; - void TokenFunc1595(x64Operand& operand, int tokenPos); - void TokenFunc1601(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1601[]; - void TokenFunc1602(x64Operand& operand, int tokenPos); - void TokenFunc1608(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1608[]; - void TokenFunc1609(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1614[]; - void TokenFunc1615(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1615[]; - void TokenFunc1616(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1623[]; - void TokenFunc1624(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1624[]; - void TokenFunc1625(x64Operand& operand, int tokenPos); - void TokenFunc1633(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1633[]; - void TokenFunc1634(x64Operand& operand, int tokenPos); - void TokenFunc1642(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1642[]; - void TokenFunc1643(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1648[]; - void TokenFunc1649(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1649[]; - void TokenFunc1650(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1657[]; - void TokenFunc1658(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1658[]; - void TokenFunc1659(x64Operand& operand, int tokenPos); - void TokenFunc1667(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1667[]; - void TokenFunc1668(x64Operand& operand, int tokenPos); - void TokenFunc1676(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1676[]; - void TokenFunc1677(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1682[]; - void TokenFunc1683(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1683[]; - void TokenFunc1684(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1691[]; - void TokenFunc1692(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1692[]; - void TokenFunc1693(x64Operand& operand, int tokenPos); - void TokenFunc1701(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1701[]; - void TokenFunc1702(x64Operand& operand, int tokenPos); - void TokenFunc1710(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1710[]; - void TokenFunc1711(x64Operand& operand, int tokenPos); - void TokenFunc1715(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1715[]; - void TokenFunc1716(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1721[]; - void TokenFunc1722(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1722[]; - void TokenFunc1723(x64Operand& operand, int tokenPos); - void TokenFunc1729(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1729[]; - void TokenFunc1730(x64Operand& operand, int tokenPos); - void TokenFunc1736(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1736[]; - void TokenFunc1737(x64Operand& operand, int tokenPos); - void TokenFunc1743(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1743[]; - void TokenFunc1744(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1751[]; - void TokenFunc1752(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1752[]; - void TokenFunc1753(x64Operand& operand, int tokenPos); - void TokenFunc1761(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1761[]; - void TokenFunc1762(x64Operand& operand, int tokenPos); - void TokenFunc1770(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1770[]; - void TokenFunc1771(x64Operand& operand, int tokenPos); - void TokenFunc1777(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1777[]; - void TokenFunc1778(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1785[]; - void TokenFunc1786(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1786[]; - void TokenFunc1787(x64Operand& operand, int tokenPos); - void TokenFunc1795(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1795[]; - void TokenFunc1796(x64Operand& operand, int tokenPos); - void TokenFunc1804(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1804[]; - void TokenFunc1805(x64Operand& operand, int tokenPos); - void TokenFunc1811(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1811[]; - void TokenFunc1812(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1819[]; - void TokenFunc1820(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1820[]; - void TokenFunc1821(x64Operand& operand, int tokenPos); - void TokenFunc1829(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1829[]; - void TokenFunc1830(x64Operand& operand, int tokenPos); - void TokenFunc1838(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1838[]; - void TokenFunc1839(x64Operand& operand, int tokenPos); - void TokenFunc1843(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1843[]; - void TokenFunc1844(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1849[]; - void TokenFunc1850(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1850[]; - void TokenFunc1851(x64Operand& operand, int tokenPos); - void TokenFunc1857(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1857[]; - void TokenFunc1858(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1864[]; - void TokenFunc1865(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1872[]; - void TokenFunc1873(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1873[]; - void TokenFunc1874(x64Operand& operand, int tokenPos); - void TokenFunc1882(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1882[]; - void TokenFunc1883(x64Operand& operand, int tokenPos); - void TokenFunc1889(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1889[]; - void TokenFunc1890(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1897[]; - void TokenFunc1898(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1898[]; - void TokenFunc1899(x64Operand& operand, int tokenPos); - void TokenFunc1907(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1907[]; - void TokenFunc1908(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1916[]; - void TokenFunc1917(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1926[]; - void TokenFunc1927(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1927[]; - void TokenFunc1928(x64Operand& operand, int tokenPos); - void TokenFunc1938(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1938[]; - void TokenFunc1939(x64Operand& operand, int tokenPos); - void TokenFunc1945(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1945[]; - void TokenFunc1946(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1953[]; - void TokenFunc1954(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1954[]; - void TokenFunc1955(x64Operand& operand, int tokenPos); - void TokenFunc1963(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1963[]; - void TokenFunc1964(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1972[]; - void TokenFunc1973(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1982[]; - void TokenFunc1983(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1983[]; - void TokenFunc1984(x64Operand& operand, int tokenPos); - void TokenFunc1994(x64Operand& operand, int tokenPos); - static x64Token tokenBranches1994[]; - void TokenFunc1995(x64Operand& operand, int tokenPos); - void TokenFunc2001(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2001[]; - void TokenFunc2002(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2009[]; - void TokenFunc2010(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2010[]; - void TokenFunc2011(x64Operand& operand, int tokenPos); - void TokenFunc2019(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2019[]; - void TokenFunc2020(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2028[]; - void TokenFunc2029(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2038[]; - void TokenFunc2039(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2039[]; - void TokenFunc2040(x64Operand& operand, int tokenPos); - void TokenFunc2050(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2050[]; - void TokenFunc2051(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2055[]; - static x64Token tokenBranches2056[]; - void TokenFunc2057(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2057[]; - void TokenFunc2058(x64Operand& operand, int tokenPos); - void TokenFunc2062(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2062[]; - static x64Token tokenBranches2063[]; - void TokenFunc2064(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2064[]; - static x64Token tokenBranches2065[]; - void TokenFunc2066(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2066[]; - void TokenFunc2067(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2072[]; - void TokenFunc2073(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2073[]; - void TokenFunc2074(x64Operand& operand, int tokenPos); - void TokenFunc2078(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2078[]; - static x64Token tokenBranches2079[]; - void TokenFunc2080(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2080[]; - static x64Token tokenBranches2081[]; - void TokenFunc2082(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2082[]; - void TokenFunc2083(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2088[]; - void TokenFunc2089(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2089[]; - void TokenFunc2090(x64Operand& operand, int tokenPos); - void TokenFunc2096(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2096[]; - static x64Token tokenBranches2097[]; - void TokenFunc2098(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2098[]; - static x64Token tokenBranches2099[]; - void TokenFunc2100(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2100[]; - void TokenFunc2101(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2108[]; - void TokenFunc2109(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2109[]; - void TokenFunc2110(x64Operand& operand, int tokenPos); - void TokenFunc2116(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2116[]; - static x64Token tokenBranches2117[]; - void TokenFunc2118(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2118[]; - static x64Token tokenBranches2119[]; - void TokenFunc2120(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2120[]; - void TokenFunc2121(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2128[]; - void TokenFunc2129(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2129[]; - void TokenFunc2130(x64Operand& operand, int tokenPos); - void TokenFunc2136(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2136[]; - static x64Token tokenBranches2137[]; - void TokenFunc2138(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2138[]; - static x64Token tokenBranches2139[]; - void TokenFunc2140(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2140[]; - void TokenFunc2141(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2148[]; - void TokenFunc2149(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2149[]; - void TokenFunc2150(x64Operand& operand, int tokenPos); - void TokenFunc2156(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2156[]; - static x64Token tokenBranches2157[]; - void TokenFunc2158(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2158[]; - static x64Token tokenBranches2159[]; - void TokenFunc2160(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2160[]; - void TokenFunc2161(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2168[]; - void TokenFunc2169(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2169[]; - void TokenFunc2170(x64Operand& operand, int tokenPos); - void TokenFunc2176(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2176[]; - static x64Token tokenBranches2177[]; - void TokenFunc2178(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2178[]; - static x64Token tokenBranches2179[]; - void TokenFunc2180(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2180[]; - void TokenFunc2181(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2188[]; - void TokenFunc2189(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2189[]; - void TokenFunc2190(x64Operand& operand, int tokenPos); - void TokenFunc2196(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2196[]; - static x64Token tokenBranches2197[]; - void TokenFunc2198(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2198[]; - static x64Token tokenBranches2199[]; - void TokenFunc2200(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2200[]; - void TokenFunc2201(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2208[]; - void TokenFunc2209(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2209[]; - void TokenFunc2210(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2216[]; - static x64Token tokenBranches2217[]; - void TokenFunc2218(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2218[]; - void TokenFunc2219(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2225[]; - static x64Token tokenBranches2226[]; - void TokenFunc2227(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2227[]; - void TokenFunc2228(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2234[]; - static x64Token tokenBranches2235[]; - void TokenFunc2236(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2236[]; - void TokenFunc2237(x64Operand& operand, int tokenPos); - void TokenFunc2241(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2241[]; - static x64Token tokenBranches2242[]; - void TokenFunc2243(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2243[]; - static x64Token tokenBranches2244[]; - void TokenFunc2245(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2245[]; - void TokenFunc2246(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2251[]; - void TokenFunc2252(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2252[]; - void TokenFunc2253(x64Operand& operand, int tokenPos); - void TokenFunc2257(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2257[]; - static x64Token tokenBranches2258[]; - void TokenFunc2259(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2259[]; - static x64Token tokenBranches2260[]; - void TokenFunc2261(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2261[]; - void TokenFunc2262(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2267[]; - void TokenFunc2268(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2268[]; - void TokenFunc2269(x64Operand& operand, int tokenPos); - void TokenFunc2275(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2275[]; - static x64Token tokenBranches2276[]; - void TokenFunc2277(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2277[]; - static x64Token tokenBranches2278[]; - void TokenFunc2279(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2279[]; - void TokenFunc2280(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2287[]; - void TokenFunc2288(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2288[]; - void TokenFunc2289(x64Operand& operand, int tokenPos); - void TokenFunc2295(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2295[]; - static x64Token tokenBranches2296[]; - void TokenFunc2297(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2297[]; - static x64Token tokenBranches2298[]; - void TokenFunc2299(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2299[]; - void TokenFunc2300(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2307[]; - void TokenFunc2308(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2308[]; - void TokenFunc2309(x64Operand& operand, int tokenPos); - void TokenFunc2315(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2315[]; - static x64Token tokenBranches2316[]; - void TokenFunc2317(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2317[]; - static x64Token tokenBranches2318[]; - void TokenFunc2319(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2319[]; - void TokenFunc2320(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2327[]; - void TokenFunc2328(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2328[]; - void TokenFunc2329(x64Operand& operand, int tokenPos); - void TokenFunc2335(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2335[]; - static x64Token tokenBranches2336[]; - void TokenFunc2337(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2337[]; - static x64Token tokenBranches2338[]; - void TokenFunc2339(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2339[]; - void TokenFunc2340(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2347[]; - void TokenFunc2348(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2348[]; - void TokenFunc2349(x64Operand& operand, int tokenPos); - void TokenFunc2354(x64Operand& operand, int tokenPos); - void TokenFunc2361(x64Operand& operand, int tokenPos); - void TokenFunc2366(x64Operand& operand, int tokenPos); - void TokenFunc2373(x64Operand& operand, int tokenPos); - void TokenFunc2378(x64Operand& operand, int tokenPos); - void TokenFunc2387(x64Operand& operand, int tokenPos); - void TokenFunc2394(x64Operand& operand, int tokenPos); - void TokenFunc2403(x64Operand& operand, int tokenPos); - void TokenFunc2410(x64Operand& operand, int tokenPos); - void TokenFunc2419(x64Operand& operand, int tokenPos); - void TokenFunc2426(x64Operand& operand, int tokenPos); - void TokenFunc2435(x64Operand& operand, int tokenPos); - void TokenFunc2442(x64Operand& operand, int tokenPos); - void TokenFunc2449(x64Operand& operand, int tokenPos); - void TokenFunc2456(x64Operand& operand, int tokenPos); - void TokenFunc2463(x64Operand& operand, int tokenPos); - void TokenFunc2472(x64Operand& operand, int tokenPos); - void TokenFunc2479(x64Operand& operand, int tokenPos); - void TokenFunc2488(x64Operand& operand, int tokenPos); - void TokenFunc2495(x64Operand& operand, int tokenPos); - void TokenFunc2502(x64Operand& operand, int tokenPos); - void TokenFunc2507(x64Operand& operand, int tokenPos); - void TokenFunc2514(x64Operand& operand, int tokenPos); - void TokenFunc2519(x64Operand& operand, int tokenPos); - void TokenFunc2528(x64Operand& operand, int tokenPos); - void TokenFunc2535(x64Operand& operand, int tokenPos); - void TokenFunc2544(x64Operand& operand, int tokenPos); - void TokenFunc2551(x64Operand& operand, int tokenPos); - void TokenFunc2560(x64Operand& operand, int tokenPos); - void TokenFunc2567(x64Operand& operand, int tokenPos); - void TokenFunc2576(x64Operand& operand, int tokenPos); - void TokenFunc2583(x64Operand& operand, int tokenPos); - void TokenFunc2589(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2589[]; - void TokenFunc2590(x64Operand& operand, int tokenPos); - void TokenFunc2598(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2598[]; - void TokenFunc2599(x64Operand& operand, int tokenPos); - void TokenFunc2605(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2605[]; - void TokenFunc2606(x64Operand& operand, int tokenPos); - void TokenFunc2614(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2614[]; - void TokenFunc2615(x64Operand& operand, int tokenPos); - void TokenFunc2621(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2621[]; - void TokenFunc2622(x64Operand& operand, int tokenPos); - void TokenFunc2630(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2630[]; - void TokenFunc2631(x64Operand& operand, int tokenPos); - void TokenFunc2639(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2639[]; - void TokenFunc2640(x64Operand& operand, int tokenPos); - void TokenFunc2648(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2648[]; - void TokenFunc2649(x64Operand& operand, int tokenPos); - void TokenFunc2659(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2659[]; - void TokenFunc2660(x64Operand& operand, int tokenPos); - void TokenFunc2668(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2668[]; - void TokenFunc2669(x64Operand& operand, int tokenPos); - void TokenFunc2679(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2679[]; - void TokenFunc2680(x64Operand& operand, int tokenPos); - void TokenFunc2688(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2688[]; - void TokenFunc2689(x64Operand& operand, int tokenPos); - void TokenFunc2699(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2699[]; - void TokenFunc2700(x64Operand& operand, int tokenPos); - void TokenFunc2708(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2708[]; - void TokenFunc2709(x64Operand& operand, int tokenPos); - void TokenFunc2719(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2719[]; - void TokenFunc2720(x64Operand& operand, int tokenPos); - void TokenFunc2728(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2728[]; - void TokenFunc2729(x64Operand& operand, int tokenPos); - void TokenFunc2739(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2739[]; - void TokenFunc2740(x64Operand& operand, int tokenPos); - void TokenFunc2748(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2748[]; - void TokenFunc2749(x64Operand& operand, int tokenPos); - void TokenFunc2759(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2759[]; - void TokenFunc2760(x64Operand& operand, int tokenPos); - void TokenFunc2768(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2768[]; - void TokenFunc2769(x64Operand& operand, int tokenPos); - void TokenFunc2777(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2777[]; - void TokenFunc2778(x64Operand& operand, int tokenPos); - void TokenFunc2784(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2784[]; - void TokenFunc2785(x64Operand& operand, int tokenPos); - void TokenFunc2793(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2793[]; - void TokenFunc2794(x64Operand& operand, int tokenPos); - void TokenFunc2800(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2800[]; - void TokenFunc2801(x64Operand& operand, int tokenPos); - void TokenFunc2811(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2811[]; - void TokenFunc2812(x64Operand& operand, int tokenPos); - void TokenFunc2820(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2820[]; - void TokenFunc2821(x64Operand& operand, int tokenPos); - void TokenFunc2831(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2831[]; - void TokenFunc2832(x64Operand& operand, int tokenPos); - void TokenFunc2840(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2840[]; - void TokenFunc2841(x64Operand& operand, int tokenPos); - void TokenFunc2851(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2851[]; - void TokenFunc2852(x64Operand& operand, int tokenPos); - void TokenFunc2860(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2860[]; - void TokenFunc2861(x64Operand& operand, int tokenPos); - void TokenFunc2871(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2871[]; - void TokenFunc2872(x64Operand& operand, int tokenPos); - void TokenFunc2880(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2880[]; - void TokenFunc2881(x64Operand& operand, int tokenPos); - void TokenFunc2887(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2887[]; - void TokenFunc2888(x64Operand& operand, int tokenPos); - void TokenFunc2896(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2896[]; - void TokenFunc2897(x64Operand& operand, int tokenPos); - void TokenFunc2903(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2903[]; - void TokenFunc2904(x64Operand& operand, int tokenPos); - void TokenFunc2912(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2912[]; - void TokenFunc2913(x64Operand& operand, int tokenPos); - void TokenFunc2919(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2919[]; - void TokenFunc2920(x64Operand& operand, int tokenPos); - void TokenFunc2930(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2930[]; - void TokenFunc2931(x64Operand& operand, int tokenPos); - void TokenFunc2939(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2939[]; - void TokenFunc2940(x64Operand& operand, int tokenPos); - void TokenFunc2950(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2950[]; - void TokenFunc2951(x64Operand& operand, int tokenPos); - void TokenFunc2959(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2959[]; - void TokenFunc2960(x64Operand& operand, int tokenPos); - void TokenFunc2970(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2970[]; - void TokenFunc2971(x64Operand& operand, int tokenPos); - void TokenFunc2979(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2979[]; - void TokenFunc2980(x64Operand& operand, int tokenPos); - void TokenFunc2990(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2990[]; - void TokenFunc2991(x64Operand& operand, int tokenPos); - void TokenFunc2999(x64Operand& operand, int tokenPos); - static x64Token tokenBranches2999[]; - void TokenFunc3000(x64Operand& operand, int tokenPos); - void TokenFunc3008(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3008[]; - void TokenFunc3009(x64Operand& operand, int tokenPos); - void TokenFunc3017(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3017[]; - void TokenFunc3018(x64Operand& operand, int tokenPos); - void TokenFunc3026(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3026[]; - void TokenFunc3027(x64Operand& operand, int tokenPos); - void TokenFunc3037(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3037[]; - void TokenFunc3038(x64Operand& operand, int tokenPos); - void TokenFunc3046(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3046[]; - void TokenFunc3047(x64Operand& operand, int tokenPos); - void TokenFunc3057(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3057[]; - void TokenFunc3058(x64Operand& operand, int tokenPos); - void TokenFunc3066(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3066[]; - void TokenFunc3067(x64Operand& operand, int tokenPos); - void TokenFunc3075(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3075[]; - void TokenFunc3076(x64Operand& operand, int tokenPos); - void TokenFunc3082(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3082[]; - void TokenFunc3083(x64Operand& operand, int tokenPos); - void TokenFunc3091(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3091[]; - void TokenFunc3092(x64Operand& operand, int tokenPos); - void TokenFunc3098(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3098[]; - void TokenFunc3099(x64Operand& operand, int tokenPos); - void TokenFunc3109(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3109[]; - void TokenFunc3110(x64Operand& operand, int tokenPos); - void TokenFunc3118(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3118[]; - void TokenFunc3119(x64Operand& operand, int tokenPos); - void TokenFunc3129(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3129[]; - void TokenFunc3130(x64Operand& operand, int tokenPos); - void TokenFunc3138(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3138[]; - void TokenFunc3139(x64Operand& operand, int tokenPos); - void TokenFunc3149(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3149[]; - void TokenFunc3150(x64Operand& operand, int tokenPos); - void TokenFunc3158(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3158[]; - void TokenFunc3159(x64Operand& operand, int tokenPos); - void TokenFunc3169(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3169[]; - void TokenFunc3170(x64Operand& operand, int tokenPos); - void TokenFunc3178(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3178[]; - void TokenFunc3179(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3181[]; - void TokenFunc3182(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3184[]; - void TokenFunc3185(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3187[]; - void TokenFunc3188(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3190[]; - void TokenFunc3191(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3195[]; - void TokenFunc3196(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3200[]; - void TokenFunc3201(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3205[]; - void TokenFunc3206(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3210[]; - void TokenFunc3211(x64Operand& operand, int tokenPos); - void TokenFunc3213(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3213[]; - void TokenFunc3214(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3217[]; - static x64Token tokenBranches3218[]; - void TokenFunc3219(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3222[]; - static x64Token tokenBranches3223[]; - void TokenFunc3224(x64Operand& operand, int tokenPos); - void TokenFunc3228(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3228[]; - void TokenFunc3229(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3234[]; - static x64Token tokenBranches3235[]; - void TokenFunc3236(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3241[]; - static x64Token tokenBranches3242[]; - void TokenFunc3243(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3245[]; - static x64Token tokenBranches3246[]; - void TokenFunc3247(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3247[]; - void TokenFunc3248(x64Operand& operand, int tokenPos); - void TokenFunc3250(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3250[]; - void TokenFunc3251(x64Operand& operand, int tokenPos); - void TokenFunc3255(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3255[]; - void TokenFunc3256(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3259[]; - void TokenFunc3260(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3260[]; - void TokenFunc3261(x64Operand& operand, int tokenPos); - void TokenFunc3264(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3264[]; - void TokenFunc3265(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3268[]; - void TokenFunc3269(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3269[]; - void TokenFunc3270(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3275[]; - void TokenFunc3276(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3276[]; - void TokenFunc3277(x64Operand& operand, int tokenPos); - void TokenFunc3282(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3282[]; - void TokenFunc3283(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3288[]; - void TokenFunc3289(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3289[]; - void TokenFunc3290(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3293[]; - void TokenFunc3294(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3294[]; - void TokenFunc3295(x64Operand& operand, int tokenPos); - void TokenFunc3299(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3299[]; - void TokenFunc3300(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3305[]; - void TokenFunc3306(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3306[]; - void TokenFunc3307(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3312[]; - void TokenFunc3313(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3313[]; - void TokenFunc3314(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3319[]; - void TokenFunc3320(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3320[]; - void TokenFunc3321(x64Operand& operand, int tokenPos); - void TokenFunc3327(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3327[]; - void TokenFunc3328(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3335[]; - void TokenFunc3336(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3336[]; - void TokenFunc3337(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3344[]; - void TokenFunc3345(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3345[]; - void TokenFunc3346(x64Operand& operand, int tokenPos); - void TokenFunc3350(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3350[]; - void TokenFunc3351(x64Operand& operand, int tokenPos); - void TokenFunc3355(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3355[]; - void TokenFunc3356(x64Operand& operand, int tokenPos); - void TokenFunc3360(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3360[]; - void TokenFunc3361(x64Operand& operand, int tokenPos); - void TokenFunc3367(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3367[]; - void TokenFunc3368(x64Operand& operand, int tokenPos); - void TokenFunc3374(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3374[]; - void TokenFunc3375(x64Operand& operand, int tokenPos); - void TokenFunc3381(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3381[]; - void TokenFunc3382(x64Operand& operand, int tokenPos); - void TokenFunc3386(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3386[]; - void TokenFunc3387(x64Operand& operand, int tokenPos); - void TokenFunc3391(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3391[]; - void TokenFunc3392(x64Operand& operand, int tokenPos); - void TokenFunc3398(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3398[]; - void TokenFunc3399(x64Operand& operand, int tokenPos); - void TokenFunc3405(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3405[]; - void TokenFunc3406(x64Operand& operand, int tokenPos); - void TokenFunc3412(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3412[]; - void TokenFunc3413(x64Operand& operand, int tokenPos); - void TokenFunc3419(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3419[]; - void TokenFunc3420(x64Operand& operand, int tokenPos); - void TokenFunc3428(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3428[]; - void TokenFunc3429(x64Operand& operand, int tokenPos); - void TokenFunc3437(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3437[]; - void TokenFunc3438(x64Operand& operand, int tokenPos); - void TokenFunc3442(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3442[]; - void TokenFunc3443(x64Operand& operand, int tokenPos); - void TokenFunc3447(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3447[]; - void TokenFunc3448(x64Operand& operand, int tokenPos); - void TokenFunc3452(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3452[]; - void TokenFunc3453(x64Operand& operand, int tokenPos); - void TokenFunc3459(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3459[]; - void TokenFunc3460(x64Operand& operand, int tokenPos); - void TokenFunc3466(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3466[]; - void TokenFunc3467(x64Operand& operand, int tokenPos); - void TokenFunc3473(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3473[]; - void TokenFunc3474(x64Operand& operand, int tokenPos); - void TokenFunc3478(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3478[]; - void TokenFunc3479(x64Operand& operand, int tokenPos); - void TokenFunc3483(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3483[]; - void TokenFunc3484(x64Operand& operand, int tokenPos); - void TokenFunc3490(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3490[]; - void TokenFunc3491(x64Operand& operand, int tokenPos); - void TokenFunc3497(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3497[]; - void TokenFunc3498(x64Operand& operand, int tokenPos); - void TokenFunc3504(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3504[]; - void TokenFunc3505(x64Operand& operand, int tokenPos); - void TokenFunc3511(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3511[]; - void TokenFunc3512(x64Operand& operand, int tokenPos); - void TokenFunc3520(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3520[]; - void TokenFunc3521(x64Operand& operand, int tokenPos); - void TokenFunc3529(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3529[]; - void TokenFunc3530(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3533[]; - void TokenFunc3534(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3534[]; - void TokenFunc3535(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3540[]; - void TokenFunc3541(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3541[]; - void TokenFunc3542(x64Operand& operand, int tokenPos); - void TokenFunc3548(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3548[]; - void TokenFunc3549(x64Operand& operand, int tokenPos); - void TokenFunc3555(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3555[]; - void TokenFunc3556(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3561[]; - void TokenFunc3562(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3562[]; - void TokenFunc3563(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3570[]; - void TokenFunc3571(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3571[]; - void TokenFunc3572(x64Operand& operand, int tokenPos); - void TokenFunc3580(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3580[]; - void TokenFunc3581(x64Operand& operand, int tokenPos); - void TokenFunc3589(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3589[]; - void TokenFunc3590(x64Operand& operand, int tokenPos); - void TokenFunc3594(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3594[]; - void TokenFunc3595(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3600[]; - void TokenFunc3601(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3601[]; - void TokenFunc3602(x64Operand& operand, int tokenPos); - void TokenFunc3608(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3608[]; - void TokenFunc3609(x64Operand& operand, int tokenPos); - void TokenFunc3615(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3615[]; - void TokenFunc3616(x64Operand& operand, int tokenPos); - void TokenFunc3622(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3622[]; - void TokenFunc3623(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3630[]; - void TokenFunc3631(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3631[]; - void TokenFunc3632(x64Operand& operand, int tokenPos); - void TokenFunc3640(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3640[]; - void TokenFunc3641(x64Operand& operand, int tokenPos); - void TokenFunc3649(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3649[]; - void TokenFunc3650(x64Operand& operand, int tokenPos); - void TokenFunc3654(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3654[]; - void TokenFunc3655(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3660[]; - void TokenFunc3661(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3661[]; - void TokenFunc3662(x64Operand& operand, int tokenPos); - void TokenFunc3668(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3668[]; - void TokenFunc3669(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3676[]; - void TokenFunc3677(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3677[]; - void TokenFunc3678(x64Operand& operand, int tokenPos); - void TokenFunc3682(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3682[]; - void TokenFunc3683(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3688[]; - void TokenFunc3689(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3689[]; - void TokenFunc3690(x64Operand& operand, int tokenPos); - void TokenFunc3696(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3696[]; - void TokenFunc3697(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3704[]; - void TokenFunc3705(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3705[]; - void TokenFunc3706(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3709[]; - void TokenFunc3710(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3710[]; - void TokenFunc3711(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3716[]; - void TokenFunc3717(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3717[]; - void TokenFunc3718(x64Operand& operand, int tokenPos); - void TokenFunc3724(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3724[]; - void TokenFunc3725(x64Operand& operand, int tokenPos); - void TokenFunc3731(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3731[]; - void TokenFunc3732(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3736[]; - static x64Token tokenBranches3737[]; - void TokenFunc3738(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3738[]; - void TokenFunc3739(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3746[]; - void TokenFunc3747(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3747[]; - void TokenFunc3748(x64Operand& operand, int tokenPos); - void TokenFunc3756(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3756[]; - void TokenFunc3757(x64Operand& operand, int tokenPos); - void TokenFunc3765(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3765[]; - void TokenFunc3766(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3770[]; - static x64Token tokenBranches3771[]; - void TokenFunc3772(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3772[]; - void TokenFunc3773(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3780[]; - void TokenFunc3781(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3781[]; - void TokenFunc3782(x64Operand& operand, int tokenPos); - void TokenFunc3790(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3790[]; - void TokenFunc3791(x64Operand& operand, int tokenPos); - void TokenFunc3799(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3799[]; - void TokenFunc3800(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3805[]; - void TokenFunc3806(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3806[]; - void TokenFunc3807(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3814[]; - void TokenFunc3815(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3815[]; - void TokenFunc3816(x64Operand& operand, int tokenPos); - void TokenFunc3824(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3824[]; - void TokenFunc3825(x64Operand& operand, int tokenPos); - void TokenFunc3833(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3833[]; - void TokenFunc3834(x64Operand& operand, int tokenPos); - void TokenFunc3838(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3838[]; - void TokenFunc3839(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3844[]; - void TokenFunc3845(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3845[]; - void TokenFunc3846(x64Operand& operand, int tokenPos); - void TokenFunc3852(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3852[]; - void TokenFunc3853(x64Operand& operand, int tokenPos); - void TokenFunc3859(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3859[]; - void TokenFunc3860(x64Operand& operand, int tokenPos); - void TokenFunc3866(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3866[]; - void TokenFunc3867(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3874[]; - void TokenFunc3875(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3875[]; - void TokenFunc3876(x64Operand& operand, int tokenPos); - void TokenFunc3884(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3884[]; - void TokenFunc3885(x64Operand& operand, int tokenPos); - void TokenFunc3893(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3893[]; - void TokenFunc3894(x64Operand& operand, int tokenPos); - void TokenFunc3900(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3900[]; - void TokenFunc3901(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3908[]; - void TokenFunc3909(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3909[]; - void TokenFunc3910(x64Operand& operand, int tokenPos); - void TokenFunc3918(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3918[]; - void TokenFunc3919(x64Operand& operand, int tokenPos); - void TokenFunc3927(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3927[]; - void TokenFunc3928(x64Operand& operand, int tokenPos); - void TokenFunc3934(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3934[]; - void TokenFunc3935(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3942[]; - void TokenFunc3943(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3943[]; - void TokenFunc3944(x64Operand& operand, int tokenPos); - void TokenFunc3952(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3952[]; - void TokenFunc3953(x64Operand& operand, int tokenPos); - void TokenFunc3961(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3961[]; - void TokenFunc3962(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3965[]; - void TokenFunc3966(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3966[]; - void TokenFunc3967(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3972[]; - void TokenFunc3973(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3973[]; - void TokenFunc3974(x64Operand& operand, int tokenPos); - void TokenFunc3980(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3980[]; - void TokenFunc3981(x64Operand& operand, int tokenPos); - void TokenFunc3987(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3987[]; - void TokenFunc3988(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3992[]; - static x64Token tokenBranches3993[]; - void TokenFunc3994(x64Operand& operand, int tokenPos); - static x64Token tokenBranches3994[]; - void TokenFunc3995(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4002[]; - void TokenFunc4003(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4003[]; - void TokenFunc4004(x64Operand& operand, int tokenPos); - void TokenFunc4012(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4012[]; - void TokenFunc4013(x64Operand& operand, int tokenPos); - void TokenFunc4021(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4021[]; - void TokenFunc4022(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4026[]; - static x64Token tokenBranches4027[]; - void TokenFunc4028(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4028[]; - void TokenFunc4029(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4036[]; - void TokenFunc4037(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4037[]; - void TokenFunc4038(x64Operand& operand, int tokenPos); - void TokenFunc4046(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4046[]; - void TokenFunc4047(x64Operand& operand, int tokenPos); - void TokenFunc4055(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4055[]; - void TokenFunc4056(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4061[]; - void TokenFunc4062(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4062[]; - void TokenFunc4063(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4070[]; - void TokenFunc4071(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4071[]; - void TokenFunc4072(x64Operand& operand, int tokenPos); - void TokenFunc4080(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4080[]; - void TokenFunc4081(x64Operand& operand, int tokenPos); - void TokenFunc4089(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4089[]; - void TokenFunc4090(x64Operand& operand, int tokenPos); - void TokenFunc4094(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4094[]; - void TokenFunc4095(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4100[]; - void TokenFunc4101(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4101[]; - void TokenFunc4102(x64Operand& operand, int tokenPos); - void TokenFunc4108(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4108[]; - void TokenFunc4109(x64Operand& operand, int tokenPos); - void TokenFunc4115(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4115[]; - void TokenFunc4116(x64Operand& operand, int tokenPos); - void TokenFunc4122(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4122[]; - void TokenFunc4123(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4130[]; - void TokenFunc4131(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4131[]; - void TokenFunc4132(x64Operand& operand, int tokenPos); - void TokenFunc4140(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4140[]; - void TokenFunc4141(x64Operand& operand, int tokenPos); - void TokenFunc4149(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4149[]; - void TokenFunc4150(x64Operand& operand, int tokenPos); - void TokenFunc4156(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4156[]; - void TokenFunc4157(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4164[]; - void TokenFunc4165(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4165[]; - void TokenFunc4166(x64Operand& operand, int tokenPos); - void TokenFunc4174(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4174[]; - void TokenFunc4175(x64Operand& operand, int tokenPos); - void TokenFunc4183(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4183[]; - void TokenFunc4184(x64Operand& operand, int tokenPos); - void TokenFunc4190(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4190[]; - void TokenFunc4191(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4198[]; - void TokenFunc4199(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4199[]; - void TokenFunc4200(x64Operand& operand, int tokenPos); - void TokenFunc4208(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4208[]; - void TokenFunc4209(x64Operand& operand, int tokenPos); - void TokenFunc4217(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4217[]; - void TokenFunc4218(x64Operand& operand, int tokenPos); - void TokenFunc4222(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4222[]; - void TokenFunc4223(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4228[]; - void TokenFunc4229(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4229[]; - void TokenFunc4230(x64Operand& operand, int tokenPos); - void TokenFunc4236(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4236[]; - void TokenFunc4237(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4244[]; - void TokenFunc4245(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4245[]; - void TokenFunc4246(x64Operand& operand, int tokenPos); - void TokenFunc4250(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4250[]; - void TokenFunc4251(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4256[]; - void TokenFunc4257(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4257[]; - void TokenFunc4258(x64Operand& operand, int tokenPos); - void TokenFunc4264(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4264[]; - void TokenFunc4265(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4272[]; - void TokenFunc4273(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4273[]; - void TokenFunc4274(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4277[]; - void TokenFunc4278(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4278[]; - void TokenFunc4279(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4284[]; - void TokenFunc4285(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4285[]; - void TokenFunc4286(x64Operand& operand, int tokenPos); - void TokenFunc4292(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4292[]; - void TokenFunc4293(x64Operand& operand, int tokenPos); - void TokenFunc4299(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4299[]; - void TokenFunc4300(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4305[]; - void TokenFunc4306(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4306[]; - void TokenFunc4307(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4314[]; - void TokenFunc4315(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4315[]; - void TokenFunc4316(x64Operand& operand, int tokenPos); - void TokenFunc4324(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4324[]; - void TokenFunc4325(x64Operand& operand, int tokenPos); - void TokenFunc4333(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4333[]; - void TokenFunc4334(x64Operand& operand, int tokenPos); - void TokenFunc4338(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4338[]; - void TokenFunc4339(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4344[]; - void TokenFunc4345(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4345[]; - void TokenFunc4346(x64Operand& operand, int tokenPos); - void TokenFunc4352(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4352[]; - void TokenFunc4353(x64Operand& operand, int tokenPos); - void TokenFunc4359(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4359[]; - void TokenFunc4360(x64Operand& operand, int tokenPos); - void TokenFunc4366(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4366[]; - void TokenFunc4367(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4374[]; - void TokenFunc4375(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4375[]; - void TokenFunc4376(x64Operand& operand, int tokenPos); - void TokenFunc4384(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4384[]; - void TokenFunc4385(x64Operand& operand, int tokenPos); - void TokenFunc4393(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4393[]; - void TokenFunc4394(x64Operand& operand, int tokenPos); - void TokenFunc4398(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4398[]; - void TokenFunc4399(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4404[]; - void TokenFunc4405(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4405[]; - void TokenFunc4406(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4412[]; - void TokenFunc4413(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4420[]; - void TokenFunc4421(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4421[]; - void TokenFunc4422(x64Operand& operand, int tokenPos); - void TokenFunc4428(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4428[]; - void TokenFunc4429(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4436[]; - void TokenFunc4437(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4437[]; - void TokenFunc4438(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4446[]; - void TokenFunc4447(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4456[]; - void TokenFunc4457(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4457[]; - void TokenFunc4458(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4462[]; - static x64Token tokenBranches4463[]; - void TokenFunc4464(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4464[]; - void TokenFunc4465(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4469[]; - static x64Token tokenBranches4470[]; - void TokenFunc4471(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4471[]; - void TokenFunc4472(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4478[]; - static x64Token tokenBranches4479[]; - void TokenFunc4480(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4480[]; - void TokenFunc4481(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4487[]; - static x64Token tokenBranches4488[]; - void TokenFunc4489(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4489[]; - void TokenFunc4490(x64Operand& operand, int tokenPos); - void TokenFunc4494(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4494[]; - static x64Token tokenBranches4495[]; - void TokenFunc4496(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4496[]; - static x64Token tokenBranches4497[]; - void TokenFunc4498(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4498[]; - void TokenFunc4499(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4504[]; - void TokenFunc4505(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4505[]; - void TokenFunc4506(x64Operand& operand, int tokenPos); - void TokenFunc4510(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4510[]; - static x64Token tokenBranches4511[]; - void TokenFunc4512(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4512[]; - static x64Token tokenBranches4513[]; - void TokenFunc4514(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4514[]; - void TokenFunc4515(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4520[]; - void TokenFunc4521(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4521[]; - void TokenFunc4522(x64Operand& operand, int tokenPos); - void TokenFunc4526(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4526[]; - static x64Token tokenBranches4527[]; - void TokenFunc4528(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4528[]; - static x64Token tokenBranches4529[]; - void TokenFunc4530(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4530[]; - void TokenFunc4531(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4536[]; - void TokenFunc4537(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4537[]; - void TokenFunc4538(x64Operand& operand, int tokenPos); - void TokenFunc4544(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4544[]; - static x64Token tokenBranches4545[]; - void TokenFunc4546(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4546[]; - static x64Token tokenBranches4547[]; - void TokenFunc4548(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4548[]; - void TokenFunc4549(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4556[]; - void TokenFunc4557(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4557[]; - void TokenFunc4558(x64Operand& operand, int tokenPos); - void TokenFunc4564(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4564[]; - static x64Token tokenBranches4565[]; - void TokenFunc4566(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4566[]; - static x64Token tokenBranches4567[]; - void TokenFunc4568(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4568[]; - void TokenFunc4569(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4576[]; - void TokenFunc4577(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4577[]; - void TokenFunc4578(x64Operand& operand, int tokenPos); - void TokenFunc4584(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4584[]; - static x64Token tokenBranches4585[]; - void TokenFunc4586(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4586[]; - static x64Token tokenBranches4587[]; - void TokenFunc4588(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4588[]; - void TokenFunc4589(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4596[]; - void TokenFunc4597(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4597[]; - void TokenFunc4598(x64Operand& operand, int tokenPos); - void TokenFunc4602(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4602[]; - static x64Token tokenBranches4603[]; - void TokenFunc4604(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4604[]; - static x64Token tokenBranches4605[]; - void TokenFunc4606(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4606[]; - void TokenFunc4607(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4612[]; - void TokenFunc4613(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4613[]; - void TokenFunc4614(x64Operand& operand, int tokenPos); - void TokenFunc4618(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4618[]; - static x64Token tokenBranches4619[]; - void TokenFunc4620(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4620[]; - static x64Token tokenBranches4621[]; - void TokenFunc4622(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4622[]; - void TokenFunc4623(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4628[]; - void TokenFunc4629(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4629[]; - void TokenFunc4630(x64Operand& operand, int tokenPos); - void TokenFunc4636(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4636[]; - static x64Token tokenBranches4637[]; - void TokenFunc4638(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4638[]; - static x64Token tokenBranches4639[]; - void TokenFunc4640(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4640[]; - void TokenFunc4641(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4648[]; - void TokenFunc4649(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4649[]; - void TokenFunc4650(x64Operand& operand, int tokenPos); - void TokenFunc4656(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4656[]; - static x64Token tokenBranches4657[]; - void TokenFunc4658(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4658[]; - static x64Token tokenBranches4659[]; - void TokenFunc4660(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4660[]; - void TokenFunc4661(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4668[]; - void TokenFunc4669(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4669[]; - void TokenFunc4670(x64Operand& operand, int tokenPos); - void TokenFunc4675(x64Operand& operand, int tokenPos); - void TokenFunc4680(x64Operand& operand, int tokenPos); - void TokenFunc4687(x64Operand& operand, int tokenPos); - void TokenFunc4694(x64Operand& operand, int tokenPos); - void TokenFunc4701(x64Operand& operand, int tokenPos); - void TokenFunc4706(x64Operand& operand, int tokenPos); - void TokenFunc4713(x64Operand& operand, int tokenPos); - void TokenFunc4718(x64Operand& operand, int tokenPos); - void TokenFunc4725(x64Operand& operand, int tokenPos); - void TokenFunc4730(x64Operand& operand, int tokenPos); - void TokenFunc4739(x64Operand& operand, int tokenPos); - void TokenFunc4746(x64Operand& operand, int tokenPos); - void TokenFunc4755(x64Operand& operand, int tokenPos); - void TokenFunc4762(x64Operand& operand, int tokenPos); - void TokenFunc4771(x64Operand& operand, int tokenPos); - void TokenFunc4778(x64Operand& operand, int tokenPos); - void TokenFunc4785(x64Operand& operand, int tokenPos); - void TokenFunc4790(x64Operand& operand, int tokenPos); - void TokenFunc4797(x64Operand& operand, int tokenPos); - void TokenFunc4802(x64Operand& operand, int tokenPos); - void TokenFunc4811(x64Operand& operand, int tokenPos); - void TokenFunc4818(x64Operand& operand, int tokenPos); - void TokenFunc4827(x64Operand& operand, int tokenPos); - void TokenFunc4834(x64Operand& operand, int tokenPos); - void TokenFunc4840(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4840[]; - void TokenFunc4841(x64Operand& operand, int tokenPos); - void TokenFunc4847(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4847[]; - void TokenFunc4848(x64Operand& operand, int tokenPos); - void TokenFunc4856(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4856[]; - void TokenFunc4857(x64Operand& operand, int tokenPos); - void TokenFunc4865(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4865[]; - void TokenFunc4866(x64Operand& operand, int tokenPos); - void TokenFunc4874(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4874[]; - void TokenFunc4875(x64Operand& operand, int tokenPos); - void TokenFunc4881(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4881[]; - void TokenFunc4882(x64Operand& operand, int tokenPos); - void TokenFunc4890(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4890[]; - void TokenFunc4891(x64Operand& operand, int tokenPos); - void TokenFunc4897(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4897[]; - void TokenFunc4898(x64Operand& operand, int tokenPos); - void TokenFunc4906(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4906[]; - void TokenFunc4907(x64Operand& operand, int tokenPos); - void TokenFunc4913(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4913[]; - void TokenFunc4914(x64Operand& operand, int tokenPos); - void TokenFunc4924(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4924[]; - void TokenFunc4925(x64Operand& operand, int tokenPos); - void TokenFunc4933(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4933[]; - void TokenFunc4934(x64Operand& operand, int tokenPos); - void TokenFunc4944(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4944[]; - void TokenFunc4945(x64Operand& operand, int tokenPos); - void TokenFunc4953(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4953[]; - void TokenFunc4954(x64Operand& operand, int tokenPos); - void TokenFunc4964(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4964[]; - void TokenFunc4965(x64Operand& operand, int tokenPos); - void TokenFunc4973(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4973[]; - void TokenFunc4974(x64Operand& operand, int tokenPos); - void TokenFunc4982(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4982[]; - void TokenFunc4983(x64Operand& operand, int tokenPos); - void TokenFunc4989(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4989[]; - void TokenFunc4990(x64Operand& operand, int tokenPos); - void TokenFunc4998(x64Operand& operand, int tokenPos); - static x64Token tokenBranches4998[]; - void TokenFunc4999(x64Operand& operand, int tokenPos); - void TokenFunc5005(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5005[]; - void TokenFunc5006(x64Operand& operand, int tokenPos); - void TokenFunc5016(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5016[]; - void TokenFunc5017(x64Operand& operand, int tokenPos); - void TokenFunc5025(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5025[]; - void TokenFunc5026(x64Operand& operand, int tokenPos); - void TokenFunc5036(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5036[]; - void TokenFunc5037(x64Operand& operand, int tokenPos); - void TokenFunc5045(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5045[]; - void TokenFunc5046(x64Operand& operand, int tokenPos); - void TokenFunc5052(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5052[]; - void TokenFunc5053(x64Operand& operand, int tokenPos); - void TokenFunc5059(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5059[]; - void TokenFunc5060(x64Operand& operand, int tokenPos); - void TokenFunc5068(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5068[]; - void TokenFunc5069(x64Operand& operand, int tokenPos); - void TokenFunc5077(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5077[]; - void TokenFunc5078(x64Operand& operand, int tokenPos); - void TokenFunc5086(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5086[]; - void TokenFunc5087(x64Operand& operand, int tokenPos); - void TokenFunc5093(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5093[]; - void TokenFunc5094(x64Operand& operand, int tokenPos); - void TokenFunc5102(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5102[]; - void TokenFunc5103(x64Operand& operand, int tokenPos); - void TokenFunc5109(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5109[]; - void TokenFunc5110(x64Operand& operand, int tokenPos); - void TokenFunc5118(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5118[]; - void TokenFunc5119(x64Operand& operand, int tokenPos); - void TokenFunc5125(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5125[]; - void TokenFunc5126(x64Operand& operand, int tokenPos); - void TokenFunc5136(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5136[]; - void TokenFunc5137(x64Operand& operand, int tokenPos); - void TokenFunc5145(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5145[]; - void TokenFunc5146(x64Operand& operand, int tokenPos); - void TokenFunc5156(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5156[]; - void TokenFunc5157(x64Operand& operand, int tokenPos); - void TokenFunc5165(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5165[]; - void TokenFunc5166(x64Operand& operand, int tokenPos); - void TokenFunc5176(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5176[]; - void TokenFunc5177(x64Operand& operand, int tokenPos); - void TokenFunc5185(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5185[]; - void TokenFunc5186(x64Operand& operand, int tokenPos); - void TokenFunc5194(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5194[]; - void TokenFunc5195(x64Operand& operand, int tokenPos); - void TokenFunc5201(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5201[]; - void TokenFunc5202(x64Operand& operand, int tokenPos); - void TokenFunc5210(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5210[]; - void TokenFunc5211(x64Operand& operand, int tokenPos); - void TokenFunc5217(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5217[]; - void TokenFunc5218(x64Operand& operand, int tokenPos); - void TokenFunc5228(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5228[]; - void TokenFunc5229(x64Operand& operand, int tokenPos); - void TokenFunc5237(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5237[]; - void TokenFunc5238(x64Operand& operand, int tokenPos); - void TokenFunc5248(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5248[]; - void TokenFunc5249(x64Operand& operand, int tokenPos); - void TokenFunc5257(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5257[]; - void TokenFunc5258(x64Operand& operand, int tokenPos); - void TokenFunc5259(x64Operand& operand, int tokenPos); - void TokenFunc5260(x64Operand& operand, int tokenPos); - void TokenFunc5261(x64Operand& operand, int tokenPos); - void TokenFunc5262(x64Operand& operand, int tokenPos); - void TokenFunc5263(x64Operand& operand, int tokenPos); - void TokenFunc5264(x64Operand& operand, int tokenPos); - void TokenFunc5265(x64Operand& operand, int tokenPos); - void TokenFunc5266(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5267[]; - void TokenFunc5268(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5269[]; - void TokenFunc5270(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5271[]; - void TokenFunc5272(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5272[]; - static x64Token tokenBranches5273[]; - static x64Token tokenBranches5274[]; - static Coding tokenCoding5275_16[]; - static Coding tokenCoding5275_17[]; - static Coding tokenCoding5275_18[]; - static Coding tokenCoding5275_19[]; - void TokenFunc5275(x64Operand& operand, int tokenPos); - void TokenFunc5276(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5276[]; - static x64Token tokenBranches5277[]; - static x64Token tokenBranches5278[]; - static Coding tokenCoding5279_16[]; - static Coding tokenCoding5279_17[]; - static Coding tokenCoding5279_18[]; - static Coding tokenCoding5279_19[]; - void TokenFunc5279(x64Operand& operand, int tokenPos); - void TokenFunc5280(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5280[]; - static x64Token tokenBranches5281[]; - static x64Token tokenBranches5282[]; - static Coding tokenCoding5283_16[]; - static Coding tokenCoding5283_17[]; - static Coding tokenCoding5283_18[]; - static Coding tokenCoding5283_19[]; - void TokenFunc5283(x64Operand& operand, int tokenPos); - static Coding tokenCoding5287_16[]; - static Coding tokenCoding5287_17[]; - static Coding tokenCoding5287_18[]; - static Coding tokenCoding5287_19[]; - void TokenFunc5287(x64Operand& operand, int tokenPos); - static Coding tokenCoding5291_16[]; - static Coding tokenCoding5291_17[]; - static Coding tokenCoding5291_18[]; - static Coding tokenCoding5291_19[]; - void TokenFunc5291(x64Operand& operand, int tokenPos); - static Coding tokenCoding5295_16[]; - static Coding tokenCoding5295_17[]; - static Coding tokenCoding5295_18[]; - static Coding tokenCoding5295_19[]; - void TokenFunc5295(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5296[]; - void TokenFunc5297(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5297[]; - static x64Token tokenBranches5298[]; - static x64Token tokenBranches5299[]; - static Coding tokenCoding5300_16[]; - static Coding tokenCoding5300_17[]; - static Coding tokenCoding5300_18[]; - static Coding tokenCoding5300_19[]; - void TokenFunc5300(x64Operand& operand, int tokenPos); - void TokenFunc5301(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5301[]; - static x64Token tokenBranches5302[]; - static x64Token tokenBranches5303[]; - static Coding tokenCoding5304_16[]; - static Coding tokenCoding5304_17[]; - static Coding tokenCoding5304_18[]; - static Coding tokenCoding5304_19[]; - void TokenFunc5304(x64Operand& operand, int tokenPos); - void TokenFunc5305(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5305[]; - static x64Token tokenBranches5306[]; - static x64Token tokenBranches5307[]; - static Coding tokenCoding5308_16[]; - static Coding tokenCoding5308_17[]; - static Coding tokenCoding5308_18[]; - static Coding tokenCoding5308_19[]; - void TokenFunc5308(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5309[]; - static x64Token tokenBranches5310[]; - static x64Token tokenBranches5311[]; - static x64Token tokenBranches5312[]; - void TokenFunc5313(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5314[]; - static x64Token tokenBranches5315[]; - static x64Token tokenBranches5316[]; - void TokenFunc5317(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5318[]; - static x64Token tokenBranches5319[]; - static x64Token tokenBranches5320[]; - void TokenFunc5321(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5322[]; - static x64Token tokenBranches5323[]; - static x64Token tokenBranches5324[]; - void TokenFunc5325(x64Operand& operand, int tokenPos); - void TokenFunc5326(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5326[]; - static x64Token tokenBranches5327[]; - static x64Token tokenBranches5328[]; - static Coding tokenCoding5329_16[]; - static Coding tokenCoding5329_17[]; - static Coding tokenCoding5329_18[]; - static Coding tokenCoding5329_19[]; - void TokenFunc5329(x64Operand& operand, int tokenPos); - void TokenFunc5330(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5330[]; - static x64Token tokenBranches5331[]; - static x64Token tokenBranches5332[]; - static Coding tokenCoding5333_16[]; - static Coding tokenCoding5333_17[]; - static Coding tokenCoding5333_23[]; - static Coding tokenCoding5333_18[]; - static Coding tokenCoding5333_19[]; - void TokenFunc5333(x64Operand& operand, int tokenPos); - void TokenFunc5334(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5334[]; - static x64Token tokenBranches5335[]; - static x64Token tokenBranches5336[]; - static Coding tokenCoding5337_16[]; - static Coding tokenCoding5337_17[]; - static Coding tokenCoding5337_18[]; - static Coding tokenCoding5337_19[]; - void TokenFunc5337(x64Operand& operand, int tokenPos); - void TokenFunc5338(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5338[]; - static x64Token tokenBranches5339[]; - static x64Token tokenBranches5340[]; - static Coding tokenCoding5341_16[]; - static Coding tokenCoding5341_17[]; - static Coding tokenCoding5341_18[]; - static Coding tokenCoding5341_19[]; - void TokenFunc5341(x64Operand& operand, int tokenPos); - void TokenFunc5342(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5342[]; - static x64Token tokenBranches5343[]; - static x64Token tokenBranches5344[]; - static Coding tokenCoding5345_16[]; - static Coding tokenCoding5345_17[]; - static Coding tokenCoding5345_18[]; - static Coding tokenCoding5345_19[]; - void TokenFunc5345(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5346[]; - static x64Token tokenBranches5347[]; - static x64Token tokenBranches5348[]; - static Coding tokenCoding5349_16[]; - static Coding tokenCoding5349_17[]; - static Coding tokenCoding5349_18[]; - static Coding tokenCoding5349_19[]; - void TokenFunc5349(x64Operand& operand, int tokenPos); - static Coding tokenCoding5353_16[]; - static Coding tokenCoding5353_17[]; - static Coding tokenCoding5353_23[]; - static Coding tokenCoding5353_18[]; - static Coding tokenCoding5353_19[]; - void TokenFunc5353(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5354[]; - static x64Token tokenBranches5355[]; - static x64Token tokenBranches5356[]; - static Coding tokenCoding5357_16[]; - static Coding tokenCoding5357_17[]; - static Coding tokenCoding5357_18[]; - static Coding tokenCoding5357_19[]; - void TokenFunc5357(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5358[]; - static x64Token tokenBranches5359[]; - static x64Token tokenBranches5360[]; - static Coding tokenCoding5361_16[]; - static Coding tokenCoding5361_17[]; - static Coding tokenCoding5361_18[]; - static Coding tokenCoding5361_19[]; - void TokenFunc5361(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5362[]; - static x64Token tokenBranches5363[]; - static x64Token tokenBranches5364[]; - static Coding tokenCoding5365_16[]; - static Coding tokenCoding5365_17[]; - static Coding tokenCoding5365_18[]; - static Coding tokenCoding5365_19[]; - void TokenFunc5365(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5366[]; - static x64Token tokenBranches5367[]; - static x64Token tokenBranches5368[]; - static x64Token tokenBranches5369[]; - static Coding tokenCoding5370_16[]; - static Coding tokenCoding5370_17[]; - static Coding tokenCoding5370_19[]; - void TokenFunc5370(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5371[]; - static x64Token tokenBranches5372[]; - static x64Token tokenBranches5373[]; - static x64Token tokenBranches5374[]; - static Coding tokenCoding5375_16[]; - static Coding tokenCoding5375_17[]; - static Coding tokenCoding5375_19[]; - void TokenFunc5375(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5379[]; - static Coding tokenCoding5380_16[]; - static Coding tokenCoding5380_17[]; - static Coding tokenCoding5380_19[]; - void TokenFunc5380(x64Operand& operand, int tokenPos); - static Coding tokenCoding5385_16[]; - static Coding tokenCoding5385_17[]; - static Coding tokenCoding5385_19[]; - void TokenFunc5385(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5386[]; - static x64Token tokenBranches5387[]; - static x64Token tokenBranches5388[]; - static x64Token tokenBranches5389[]; - static Coding tokenCoding5390_16[]; - static Coding tokenCoding5390_17[]; - static Coding tokenCoding5390_19[]; - void TokenFunc5390(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5394[]; - static Coding tokenCoding5395_16[]; - static Coding tokenCoding5395_17[]; - static Coding tokenCoding5395_19[]; - void TokenFunc5395(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5399[]; - static Coding tokenCoding5400_16[]; - static Coding tokenCoding5400_17[]; - static Coding tokenCoding5400_19[]; - void TokenFunc5400(x64Operand& operand, int tokenPos); - static Coding tokenCoding5405_16[]; - static Coding tokenCoding5405_17[]; - static Coding tokenCoding5405_19[]; - void TokenFunc5405(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5406[]; - static x64Token tokenBranches5407[]; - static x64Token tokenBranches5408[]; - static x64Token tokenBranches5409[]; - static Coding tokenCoding5410_16[]; - static Coding tokenCoding5410_17[]; - static Coding tokenCoding5410_19[]; - void TokenFunc5410(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5414[]; - static Coding tokenCoding5415_16[]; - static Coding tokenCoding5415_17[]; - static Coding tokenCoding5415_19[]; - void TokenFunc5415(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5419[]; - static Coding tokenCoding5420_16[]; - static Coding tokenCoding5420_17[]; - static Coding tokenCoding5420_19[]; - void TokenFunc5420(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5424[]; - static Coding tokenCoding5425_16[]; - static Coding tokenCoding5425_17[]; - static Coding tokenCoding5425_19[]; - void TokenFunc5425(x64Operand& operand, int tokenPos); - static Coding tokenCoding5430_16[]; - static Coding tokenCoding5430_17[]; - static Coding tokenCoding5430_19[]; - void TokenFunc5430(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5431[]; - static x64Token tokenBranches5432[]; - static x64Token tokenBranches5433[]; - static Coding tokenCoding5434_16[]; - static Coding tokenCoding5434_17[]; - static Coding tokenCoding5434_19[]; - void TokenFunc5434(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5435[]; - static x64Token tokenBranches5436[]; - static x64Token tokenBranches5437[]; - static Coding tokenCoding5438_16[]; - static Coding tokenCoding5438_17[]; - static Coding tokenCoding5438_19[]; - void TokenFunc5438(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5441[]; - static Coding tokenCoding5442_16[]; - static Coding tokenCoding5442_17[]; - static Coding tokenCoding5442_19[]; - void TokenFunc5442(x64Operand& operand, int tokenPos); - static Coding tokenCoding5446_16[]; - static Coding tokenCoding5446_17[]; - static Coding tokenCoding5446_19[]; - void TokenFunc5446(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5447[]; - static x64Token tokenBranches5448[]; - static x64Token tokenBranches5449[]; - static Coding tokenCoding5450_16[]; - static Coding tokenCoding5450_17[]; - static Coding tokenCoding5450_19[]; - void TokenFunc5450(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5453[]; - static Coding tokenCoding5454_16[]; - static Coding tokenCoding5454_17[]; - static Coding tokenCoding5454_19[]; - void TokenFunc5454(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5457[]; - static Coding tokenCoding5458_16[]; - static Coding tokenCoding5458_17[]; - static Coding tokenCoding5458_19[]; - void TokenFunc5458(x64Operand& operand, int tokenPos); - static Coding tokenCoding5462_16[]; - static Coding tokenCoding5462_17[]; - static Coding tokenCoding5462_19[]; - void TokenFunc5462(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5463[]; - static x64Token tokenBranches5464[]; - static x64Token tokenBranches5465[]; - static Coding tokenCoding5466_16[]; - static Coding tokenCoding5466_17[]; - static Coding tokenCoding5466_19[]; - void TokenFunc5466(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5469[]; - static Coding tokenCoding5470_16[]; - static Coding tokenCoding5470_17[]; - static Coding tokenCoding5470_19[]; - void TokenFunc5470(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5473[]; - static Coding tokenCoding5474_16[]; - static Coding tokenCoding5474_17[]; - static Coding tokenCoding5474_19[]; - void TokenFunc5474(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5477[]; - static Coding tokenCoding5478_16[]; - static Coding tokenCoding5478_17[]; - static Coding tokenCoding5478_19[]; - void TokenFunc5478(x64Operand& operand, int tokenPos); - static Coding tokenCoding5482_16[]; - static Coding tokenCoding5482_17[]; - static Coding tokenCoding5482_19[]; - void TokenFunc5482(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5483[]; - static x64Token tokenBranches5484[]; - static x64Token tokenBranches5485[]; - static x64Token tokenBranches5486[]; - static x64Token tokenBranches5487[]; - static Coding tokenCoding5488_16[]; - static Coding tokenCoding5488_17[]; - static Coding tokenCoding5488_19[]; - void TokenFunc5488(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5489[]; - static x64Token tokenBranches5490[]; - static x64Token tokenBranches5491[]; - static x64Token tokenBranches5492[]; - static Coding tokenCoding5493_16[]; - static Coding tokenCoding5493_17[]; - static Coding tokenCoding5493_19[]; - void TokenFunc5493(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5494[]; - static x64Token tokenBranches5495[]; - static x64Token tokenBranches5496[]; - static x64Token tokenBranches5497[]; - static Coding tokenCoding5498_16[]; - static Coding tokenCoding5498_17[]; - static Coding tokenCoding5498_19[]; - void TokenFunc5498(x64Operand& operand, int tokenPos); - static Coding tokenCoding5502_16[]; - static Coding tokenCoding5502_17[]; - static Coding tokenCoding5502_18[]; - static Coding tokenCoding5502_19[]; - void TokenFunc5502(x64Operand& operand, int tokenPos); - static Coding tokenCoding5506_16[]; - static Coding tokenCoding5506_17[]; - static Coding tokenCoding5506_18[]; - static Coding tokenCoding5506_19[]; - void TokenFunc5506(x64Operand& operand, int tokenPos); - static Coding tokenCoding5510_16[]; - static Coding tokenCoding5510_17[]; - static Coding tokenCoding5510_18[]; - static Coding tokenCoding5510_19[]; - void TokenFunc5510(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5511[]; - static Coding tokenCoding5512_16[]; - static Coding tokenCoding5512_17[]; - static Coding tokenCoding5512_19[]; - void TokenFunc5512(x64Operand& operand, int tokenPos); - void TokenFunc5513(x64Operand& operand, int tokenPos); - void TokenFunc5514(x64Operand& operand, int tokenPos); - void TokenFunc5515(x64Operand& operand, int tokenPos); - static Coding tokenCoding5516_16[]; - static Coding tokenCoding5516_17[]; - static Coding tokenCoding5516_19[]; - void TokenFunc5516(x64Operand& operand, int tokenPos); - static Coding tokenCoding5517_16[]; - static Coding tokenCoding5517_17[]; - static Coding tokenCoding5517_19[]; - void TokenFunc5517(x64Operand& operand, int tokenPos); - static Coding tokenCoding5518_16[]; - static Coding tokenCoding5518_17[]; - static Coding tokenCoding5518_19[]; - void TokenFunc5518(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5519[]; - static Coding tokenCoding5520_16[]; - static Coding tokenCoding5520_17[]; - static Coding tokenCoding5520_19[]; - void TokenFunc5520(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5521[]; - static Coding tokenCoding5522_16[]; - static Coding tokenCoding5522_17[]; - static Coding tokenCoding5522_19[]; - void TokenFunc5522(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5523[]; - static Coding tokenCoding5524_16[]; - static Coding tokenCoding5524_17[]; - static Coding tokenCoding5524_19[]; - void TokenFunc5524(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5525[]; - static Coding tokenCoding5526_16[]; - static Coding tokenCoding5526_17[]; - static Coding tokenCoding5526_19[]; - void TokenFunc5526(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5527[]; - static Coding tokenCoding5528_16[]; - static Coding tokenCoding5528_17[]; - static Coding tokenCoding5528_19[]; - void TokenFunc5528(x64Operand& operand, int tokenPos); - static Coding tokenCoding5529_16[]; - static Coding tokenCoding5529_17[]; - static Coding tokenCoding5529_19[]; - void TokenFunc5529(x64Operand& operand, int tokenPos); - static Coding tokenCoding5530_16[]; - static Coding tokenCoding5530_17[]; - static Coding tokenCoding5530_19[]; - void TokenFunc5530(x64Operand& operand, int tokenPos); - static Coding tokenCoding5531_16[]; - static Coding tokenCoding5531_17[]; - static Coding tokenCoding5531_19[]; - void TokenFunc5531(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5532[]; - static Coding tokenCoding5533_16[]; - static Coding tokenCoding5533_17[]; - static Coding tokenCoding5533_19[]; - void TokenFunc5533(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5534[]; - static Coding tokenCoding5535_16[]; - static Coding tokenCoding5535_17[]; - static Coding tokenCoding5535_19[]; - void TokenFunc5535(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5536[]; - static Coding tokenCoding5537_16[]; - static Coding tokenCoding5537_17[]; - static Coding tokenCoding5537_19[]; - void TokenFunc5537(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5538[]; - static Coding tokenCoding5539_16[]; - static Coding tokenCoding5539_17[]; - static Coding tokenCoding5539_19[]; - void TokenFunc5539(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5540[]; - static x64Token tokenBranches5541[]; - static x64Token tokenBranches5542[]; - void TokenFunc5543(x64Operand& operand, int tokenPos); - void TokenFunc5544(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5544[]; - static x64Token tokenBranches5545[]; - void TokenFunc5546(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5548[]; - static Coding tokenCoding5549_16[]; - static Coding tokenCoding5549_17[]; - static Coding tokenCoding5549_19[]; - void TokenFunc5549(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5550[]; - static Coding tokenCoding5551_16[]; - static Coding tokenCoding5551_17[]; - static Coding tokenCoding5551_19[]; - void TokenFunc5551(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5552[]; - void TokenFunc5553(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5553[]; - static x64Token tokenBranches5554[]; - void TokenFunc5555(x64Operand& operand, int tokenPos); - void TokenFunc5557(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5558[]; - static x64Token tokenBranches5559[]; - static Coding tokenCoding5560_16[]; - static Coding tokenCoding5560_17[]; - static Coding tokenCoding5560_19[]; - void TokenFunc5560(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5561[]; - static Coding tokenCoding5562_16[]; - static Coding tokenCoding5562_17[]; - static Coding tokenCoding5562_19[]; - void TokenFunc5562(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5563[]; - static x64Token tokenBranches5564[]; - static Coding tokenCoding5565_16[]; - static Coding tokenCoding5565_17[]; - void TokenFunc5565(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5566[]; - static x64Token tokenBranches5567[]; - void TokenFunc5568(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5569[]; - void TokenFunc5570(x64Operand& operand, int tokenPos); - void TokenFunc5572(x64Operand& operand, int tokenPos); - void TokenFunc5573(x64Operand& operand, int tokenPos); - void TokenFunc5574(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5575[]; - void TokenFunc5576(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5576[]; - static x64Token tokenBranches5577[]; - static x64Token tokenBranches5578[]; - static Coding tokenCoding5579_16[]; - static Coding tokenCoding5579_17[]; - static Coding tokenCoding5579_18[]; - static Coding tokenCoding5579_19[]; - void TokenFunc5579(x64Operand& operand, int tokenPos); - void TokenFunc5580(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5580[]; - static x64Token tokenBranches5581[]; - static x64Token tokenBranches5582[]; - static Coding tokenCoding5583_16[]; - static Coding tokenCoding5583_17[]; - static Coding tokenCoding5583_18[]; - static Coding tokenCoding5583_19[]; - void TokenFunc5583(x64Operand& operand, int tokenPos); - void TokenFunc5584(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5584[]; - static x64Token tokenBranches5585[]; - static x64Token tokenBranches5586[]; - static Coding tokenCoding5587_16[]; - static Coding tokenCoding5587_17[]; - static Coding tokenCoding5587_18[]; - static Coding tokenCoding5587_19[]; - void TokenFunc5587(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5588[]; - static x64Token tokenBranches5589[]; - static Coding tokenCoding5590_16[]; - static Coding tokenCoding5590_17[]; - static Coding tokenCoding5590_18[]; - static Coding tokenCoding5590_19[]; - void TokenFunc5590(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5591[]; - void TokenFunc5592(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5592[]; - static x64Token tokenBranches5593[]; - static Coding tokenCoding5594_16[]; - static Coding tokenCoding5594_17[]; - static Coding tokenCoding5594_18[]; - static Coding tokenCoding5594_19[]; - void TokenFunc5594(x64Operand& operand, int tokenPos); - void TokenFunc5595(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5595[]; - static x64Token tokenBranches5596[]; - static Coding tokenCoding5597_16[]; - static Coding tokenCoding5597_17[]; - static Coding tokenCoding5597_18[]; - static Coding tokenCoding5597_19[]; - void TokenFunc5597(x64Operand& operand, int tokenPos); - static Coding tokenCoding5600_16[]; - static Coding tokenCoding5600_17[]; - static Coding tokenCoding5600_18[]; - static Coding tokenCoding5600_19[]; - void TokenFunc5600(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5603[]; - static Coding tokenCoding5604_16[]; - static Coding tokenCoding5604_17[]; - static Coding tokenCoding5604_18[]; - static Coding tokenCoding5604_19[]; - void TokenFunc5604(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5607[]; - static Coding tokenCoding5608_16[]; - static Coding tokenCoding5608_17[]; - static Coding tokenCoding5608_18[]; - static Coding tokenCoding5608_19[]; - void TokenFunc5608(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5611[]; - static Coding tokenCoding5612_16[]; - static Coding tokenCoding5612_17[]; - static Coding tokenCoding5612_18[]; - static Coding tokenCoding5612_19[]; - void TokenFunc5612(x64Operand& operand, int tokenPos); - void TokenFunc5613(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5613[]; - static x64Token tokenBranches5614[]; - static Coding tokenCoding5615_16[]; - static Coding tokenCoding5615_17[]; - static Coding tokenCoding5615_18[]; - static Coding tokenCoding5615_19[]; - void TokenFunc5615(x64Operand& operand, int tokenPos); - static Coding tokenCoding5618_16[]; - static Coding tokenCoding5618_17[]; - static Coding tokenCoding5618_18[]; - static Coding tokenCoding5618_19[]; - void TokenFunc5618(x64Operand& operand, int tokenPos); - static Coding tokenCoding5621_16[]; - static Coding tokenCoding5621_17[]; - static Coding tokenCoding5621_18[]; - static Coding tokenCoding5621_19[]; - void TokenFunc5621(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5624[]; - static Coding tokenCoding5625_16[]; - static Coding tokenCoding5625_17[]; - static Coding tokenCoding5625_18[]; - static Coding tokenCoding5625_19[]; - void TokenFunc5625(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5628[]; - static Coding tokenCoding5629_16[]; - static Coding tokenCoding5629_17[]; - static Coding tokenCoding5629_18[]; - static Coding tokenCoding5629_19[]; - void TokenFunc5629(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5632[]; - static Coding tokenCoding5633_16[]; - static Coding tokenCoding5633_17[]; - static Coding tokenCoding5633_18[]; - static Coding tokenCoding5633_19[]; - void TokenFunc5633(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5634[]; - static x64Token tokenBranches5635[]; - static x64Token tokenBranches5636[]; - static Coding tokenCoding5637_16[]; - static Coding tokenCoding5637_17[]; - static Coding tokenCoding5637_19[]; - void TokenFunc5637(x64Operand& operand, int tokenPos); - static Coding tokenCoding5640_16[]; - static Coding tokenCoding5640_17[]; - static Coding tokenCoding5640_19[]; - void TokenFunc5640(x64Operand& operand, int tokenPos); - static Coding tokenCoding5643_16[]; - static Coding tokenCoding5643_17[]; - static Coding tokenCoding5643_19[]; - void TokenFunc5643(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5644[]; - static x64Token tokenBranches5645[]; - static x64Token tokenBranches5646[]; - static x64Token tokenBranches5647[]; - static Coding tokenCoding5648_16[]; - static Coding tokenCoding5648_17[]; - static Coding tokenCoding5648_19[]; - void TokenFunc5648(x64Operand& operand, int tokenPos); - static Coding tokenCoding5653_16[]; - static Coding tokenCoding5653_17[]; - static Coding tokenCoding5653_19[]; - void TokenFunc5653(x64Operand& operand, int tokenPos); - static Coding tokenCoding5657_16[]; - static Coding tokenCoding5657_17[]; - static Coding tokenCoding5657_19[]; - void TokenFunc5657(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5658[]; - static x64Token tokenBranches5659[]; - static Coding tokenCoding5660_16[]; - static Coding tokenCoding5660_17[]; - static Coding tokenCoding5660_19[]; - void TokenFunc5660(x64Operand& operand, int tokenPos); - static Coding tokenCoding5663_16[]; - static Coding tokenCoding5663_17[]; - static Coding tokenCoding5663_19[]; - void TokenFunc5663(x64Operand& operand, int tokenPos); - static Coding tokenCoding5666_16[]; - static Coding tokenCoding5666_17[]; - static Coding tokenCoding5666_19[]; - void TokenFunc5666(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5667[]; - static x64Token tokenBranches5668[]; - static x64Token tokenBranches5669[]; - static x64Token tokenBranches5670[]; - static Coding tokenCoding5671_16[]; - static Coding tokenCoding5671_17[]; - static Coding tokenCoding5671_19[]; - void TokenFunc5671(x64Operand& operand, int tokenPos); - static Coding tokenCoding5676_16[]; - static Coding tokenCoding5676_17[]; - static Coding tokenCoding5676_19[]; - void TokenFunc5676(x64Operand& operand, int tokenPos); - static Coding tokenCoding5680_16[]; - static Coding tokenCoding5680_17[]; - static Coding tokenCoding5680_19[]; - void TokenFunc5680(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5681[]; - static x64Token tokenBranches5682[]; - static Coding tokenCoding5683_16[]; - static Coding tokenCoding5683_17[]; - static Coding tokenCoding5683_19[]; - void TokenFunc5683(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5686[]; - static Coding tokenCoding5687_16[]; - static Coding tokenCoding5687_17[]; - static Coding tokenCoding5687_19[]; - void TokenFunc5687(x64Operand& operand, int tokenPos); - static Coding tokenCoding5690_16[]; - static Coding tokenCoding5690_17[]; - static Coding tokenCoding5690_19[]; - void TokenFunc5690(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5691[]; - static x64Token tokenBranches5692[]; - static x64Token tokenBranches5693[]; - static x64Token tokenBranches5694[]; - static Coding tokenCoding5695_16[]; - static Coding tokenCoding5695_17[]; - static Coding tokenCoding5695_19[]; - void TokenFunc5695(x64Operand& operand, int tokenPos); - static Coding tokenCoding5700_16[]; - static Coding tokenCoding5700_17[]; - static Coding tokenCoding5700_19[]; - void TokenFunc5700(x64Operand& operand, int tokenPos); - static Coding tokenCoding5704_16[]; - static Coding tokenCoding5704_17[]; - static Coding tokenCoding5704_19[]; - void TokenFunc5704(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5705[]; - static x64Token tokenBranches5706[]; - static Coding tokenCoding5707_16[]; - static Coding tokenCoding5707_17[]; - static Coding tokenCoding5707_19[]; - void TokenFunc5707(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5710[]; - static Coding tokenCoding5711_16[]; - static Coding tokenCoding5711_17[]; - static Coding tokenCoding5711_19[]; - void TokenFunc5711(x64Operand& operand, int tokenPos); - static Coding tokenCoding5714_16[]; - static Coding tokenCoding5714_17[]; - static Coding tokenCoding5714_19[]; - void TokenFunc5714(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5715[]; - static x64Token tokenBranches5716[]; - static x64Token tokenBranches5717[]; - static x64Token tokenBranches5718[]; - static Coding tokenCoding5719_16[]; - static Coding tokenCoding5719_17[]; - static Coding tokenCoding5719_19[]; - void TokenFunc5719(x64Operand& operand, int tokenPos); - static Coding tokenCoding5724_16[]; - static Coding tokenCoding5724_17[]; - static Coding tokenCoding5724_19[]; - void TokenFunc5724(x64Operand& operand, int tokenPos); - static Coding tokenCoding5728_16[]; - static Coding tokenCoding5728_17[]; - static Coding tokenCoding5728_19[]; - void TokenFunc5728(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5729[]; - static x64Token tokenBranches5730[]; - static x64Token tokenBranches5731[]; - static x64Token tokenBranches5732[]; - void TokenFunc5733(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5733[]; - static x64Token tokenBranches5734[]; - static Coding tokenCoding5735_16[]; - static Coding tokenCoding5735_17[]; - static Coding tokenCoding5735_18[]; - static Coding tokenCoding5735_19[]; - void TokenFunc5735(x64Operand& operand, int tokenPos); - static Coding tokenCoding5741_16[]; - static Coding tokenCoding5741_17[]; - static Coding tokenCoding5741_18[]; - static Coding tokenCoding5741_19[]; - void TokenFunc5741(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5742[]; - static x64Token tokenBranches5743[]; - static x64Token tokenBranches5744[]; - void TokenFunc5745(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5745[]; - static x64Token tokenBranches5746[]; - static Coding tokenCoding5747_16[]; - static Coding tokenCoding5747_17[]; - static Coding tokenCoding5747_18[]; - static Coding tokenCoding5747_19[]; - void TokenFunc5747(x64Operand& operand, int tokenPos); - static Coding tokenCoding5753_16[]; - static Coding tokenCoding5753_17[]; - static Coding tokenCoding5753_18[]; - static Coding tokenCoding5753_19[]; - void TokenFunc5753(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5754[]; - static x64Token tokenBranches5755[]; - static x64Token tokenBranches5756[]; - void TokenFunc5757(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5757[]; - static x64Token tokenBranches5758[]; - static Coding tokenCoding5759_16[]; - static Coding tokenCoding5759_17[]; - static Coding tokenCoding5759_18[]; - static Coding tokenCoding5759_19[]; - void TokenFunc5759(x64Operand& operand, int tokenPos); - static Coding tokenCoding5765_16[]; - static Coding tokenCoding5765_17[]; - static Coding tokenCoding5765_18[]; - static Coding tokenCoding5765_19[]; - void TokenFunc5765(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5766[]; - static Coding tokenCoding5767_16[]; - static Coding tokenCoding5767_17[]; - void TokenFunc5767(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5768[]; - void TokenFunc5769(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5769[]; - static x64Token tokenBranches5770[]; - static Coding tokenCoding5771_16[]; - static Coding tokenCoding5771_17[]; - static Coding tokenCoding5771_18[]; - void TokenFunc5771(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5772[]; - void TokenFunc5773(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5773[]; - static x64Token tokenBranches5774[]; - static Coding tokenCoding5775_16[]; - static Coding tokenCoding5775_17[]; - static Coding tokenCoding5775_18[]; - static Coding tokenCoding5775_19[]; - void TokenFunc5775(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5776[]; - static x64Token tokenBranches5777[]; - static Coding tokenCoding5778_16[]; - static Coding tokenCoding5778_17[]; - static Coding tokenCoding5778_18[]; - static Coding tokenCoding5778_19[]; - void TokenFunc5778(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5779[]; - void TokenFunc5780(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5780[]; - static x64Token tokenBranches5781[]; - static Coding tokenCoding5782_16[]; - static Coding tokenCoding5782_17[]; - static Coding tokenCoding5782_18[]; - static Coding tokenCoding5782_19[]; - void TokenFunc5782(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5783[]; - static x64Token tokenBranches5784[]; - static Coding tokenCoding5785_16[]; - static Coding tokenCoding5785_17[]; - static Coding tokenCoding5785_18[]; - static Coding tokenCoding5785_19[]; - void TokenFunc5785(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5786[]; - void TokenFunc5787(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5787[]; - static x64Token tokenBranches5788[]; - static Coding tokenCoding5789_16[]; - static Coding tokenCoding5789_17[]; - static Coding tokenCoding5789_18[]; - static Coding tokenCoding5789_19[]; - void TokenFunc5789(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5790[]; - static x64Token tokenBranches5791[]; - static Coding tokenCoding5792_16[]; - static Coding tokenCoding5792_17[]; - static Coding tokenCoding5792_18[]; - static Coding tokenCoding5792_19[]; - void TokenFunc5792(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5793[]; - void TokenFunc5794(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5794[]; - static x64Token tokenBranches5795[]; - static Coding tokenCoding5796_16[]; - static Coding tokenCoding5796_17[]; - static Coding tokenCoding5796_18[]; - void TokenFunc5796(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5797[]; - void TokenFunc5798(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5798[]; - static x64Token tokenBranches5799[]; - static Coding tokenCoding5800_16[]; - static Coding tokenCoding5800_17[]; - static Coding tokenCoding5800_18[]; - void TokenFunc5800(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5801[]; - void TokenFunc5802(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5802[]; - static x64Token tokenBranches5803[]; - static Coding tokenCoding5804_16[]; - static Coding tokenCoding5804_17[]; - static Coding tokenCoding5804_18[]; - void TokenFunc5804(x64Operand& operand, int tokenPos); - void TokenFunc5805(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5805[]; - static x64Token tokenBranches5806[]; - static Coding tokenCoding5807_16[]; - static Coding tokenCoding5807_17[]; - static Coding tokenCoding5807_18[]; - void TokenFunc5807(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5808[]; - void TokenFunc5809(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5809[]; - static x64Token tokenBranches5810[]; - static x64Token tokenBranches5811[]; - static Coding tokenCoding5812_16[]; - static Coding tokenCoding5812_17[]; - static Coding tokenCoding5812_18[]; - void TokenFunc5812(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5815[]; - static Coding tokenCoding5816_16[]; - static Coding tokenCoding5816_17[]; - static Coding tokenCoding5816_18[]; - void TokenFunc5816(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5817[]; - void TokenFunc5818(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5818[]; - static x64Token tokenBranches5819[]; - static Coding tokenCoding5820_16[]; - static Coding tokenCoding5820_17[]; - static Coding tokenCoding5820_23[]; - static Coding tokenCoding5820_18[]; - void TokenFunc5820(x64Operand& operand, int tokenPos); - void TokenFunc5821(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5821[]; - static x64Token tokenBranches5822[]; - static Coding tokenCoding5823_16[]; - static Coding tokenCoding5823_17[]; - static Coding tokenCoding5823_23[]; - static Coding tokenCoding5823_18[]; - void TokenFunc5823(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5824[]; - void TokenFunc5825(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5825[]; - static x64Token tokenBranches5826[]; - static x64Token tokenBranches5827[]; - static x64Token tokenBranches5828[]; - static Coding tokenCoding5829_16[]; - static Coding tokenCoding5829_17[]; - static Coding tokenCoding5829_18[]; - void TokenFunc5829(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5830[]; - static x64Token tokenBranches5831[]; - static x64Token tokenBranches5832[]; - static Coding tokenCoding5833_16[]; - static Coding tokenCoding5833_17[]; - static Coding tokenCoding5833_23[]; - static Coding tokenCoding5833_18[]; - static Coding tokenCoding5833_19[]; - void TokenFunc5833(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5834[]; - static x64Token tokenBranches5835[]; - static Coding tokenCoding5836_16[]; - static Coding tokenCoding5836_17[]; - static Coding tokenCoding5836_23[]; - static Coding tokenCoding5836_18[]; - static Coding tokenCoding5836_19[]; - void TokenFunc5836(x64Operand& operand, int tokenPos); - void TokenFunc5837(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5837[]; - static x64Token tokenBranches5838[]; - static Coding tokenCoding5839_16[]; - static Coding tokenCoding5839_17[]; - static Coding tokenCoding5839_23[]; - static Coding tokenCoding5839_18[]; - static Coding tokenCoding5839_19[]; - void TokenFunc5839(x64Operand& operand, int tokenPos); - void TokenFunc5840(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5840[]; - static x64Token tokenBranches5841[]; - static Coding tokenCoding5842_16[]; - static Coding tokenCoding5842_17[]; - static Coding tokenCoding5842_23[]; - static Coding tokenCoding5842_18[]; - static Coding tokenCoding5842_19[]; - void TokenFunc5842(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5843[]; - void TokenFunc5844(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5844[]; - static x64Token tokenBranches5845[]; - static x64Token tokenBranches5846[]; - static x64Token tokenBranches5847[]; - static Coding tokenCoding5848_16[]; - static Coding tokenCoding5848_17[]; - static Coding tokenCoding5848_18[]; - void TokenFunc5848(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5849[]; - void TokenFunc5850(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5850[]; - static x64Token tokenBranches5851[]; - static x64Token tokenBranches5852[]; - static x64Token tokenBranches5853[]; - static Coding tokenCoding5854_16[]; - static Coding tokenCoding5854_17[]; - static Coding tokenCoding5854_18[]; - void TokenFunc5854(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5862[]; - static x64Token tokenBranches5863[]; - static x64Token tokenBranches5864[]; - static Coding tokenCoding5865_16[]; - static Coding tokenCoding5865_17[]; - static Coding tokenCoding5865_18[]; - static Coding tokenCoding5865_19[]; - void TokenFunc5865(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5869[]; - static Coding tokenCoding5870_16[]; - static Coding tokenCoding5870_17[]; - static Coding tokenCoding5870_18[]; - void TokenFunc5870(x64Operand& operand, int tokenPos); - static Coding tokenCoding5871_16[]; - static Coding tokenCoding5871_17[]; - static Coding tokenCoding5871_18[]; - void TokenFunc5871(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5876[]; - void TokenFunc5877(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5877[]; - static x64Token tokenBranches5878[]; - static x64Token tokenBranches5879[]; - void TokenFunc5880(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5883[]; - void TokenFunc5884(x64Operand& operand, int tokenPos); - void TokenFunc5885(x64Operand& operand, int tokenPos); - void TokenFunc5886(x64Operand& operand, int tokenPos); - static Coding tokenCoding5887_16[]; - static Coding tokenCoding5887_17[]; - static Coding tokenCoding5887_18[]; - static Coding tokenCoding5887_19[]; - void TokenFunc5887(x64Operand& operand, int tokenPos); - static Coding tokenCoding5888_16[]; - static Coding tokenCoding5888_17[]; - static Coding tokenCoding5888_18[]; - static Coding tokenCoding5888_19[]; - void TokenFunc5888(x64Operand& operand, int tokenPos); - static Coding tokenCoding5889_16[]; - static Coding tokenCoding5889_17[]; - static Coding tokenCoding5889_18[]; - static Coding tokenCoding5889_19[]; - void TokenFunc5889(x64Operand& operand, int tokenPos); - static Coding tokenCoding5890_16[]; - static Coding tokenCoding5890_17[]; - static Coding tokenCoding5890_18[]; - static Coding tokenCoding5890_19[]; - void TokenFunc5890(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5891[]; - static Coding tokenCoding5892_16[]; - static Coding tokenCoding5892_17[]; - static Coding tokenCoding5892_18[]; - static Coding tokenCoding5892_19[]; - void TokenFunc5892(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5893[]; - static Coding tokenCoding5894_16[]; - static Coding tokenCoding5894_17[]; - static Coding tokenCoding5894_18[]; - static Coding tokenCoding5894_19[]; - void TokenFunc5894(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5895[]; - static Coding tokenCoding5896_16[]; - static Coding tokenCoding5896_17[]; - static Coding tokenCoding5896_18[]; - static Coding tokenCoding5896_19[]; - void TokenFunc5896(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5897[]; - void TokenFunc5898(x64Operand& operand, int tokenPos); - void TokenFunc5900(x64Operand& operand, int tokenPos); - static Coding tokenCoding5902_16[]; - static Coding tokenCoding5902_17[]; - static Coding tokenCoding5902_18[]; - static Coding tokenCoding5902_19[]; - void TokenFunc5902(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5904[]; - static Coding tokenCoding5905_16[]; - static Coding tokenCoding5905_17[]; - static Coding tokenCoding5905_18[]; - static Coding tokenCoding5905_19[]; - void TokenFunc5905(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5907[]; - static Coding tokenCoding5908_16[]; - static Coding tokenCoding5908_17[]; - static Coding tokenCoding5908_18[]; - static Coding tokenCoding5908_19[]; - void TokenFunc5908(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5911[]; - void TokenFunc5912(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5949[]; - static x64Token tokenBranches5950[]; - static x64Token tokenBranches5951[]; - static x64Token tokenBranches5952[]; - static x64Token tokenBranches5953[]; - static x64Token tokenBranches5954[]; - static x64Token tokenBranches5955[]; - static x64Token tokenBranches5956[]; - static x64Token tokenBranches5957[]; - static x64Token tokenBranches5958[]; - static x64Token tokenBranches5959[]; - static x64Token tokenBranches5960[]; - static x64Token tokenBranches5961[]; - void TokenFunc5962(x64Operand& operand, int tokenPos); - void TokenFunc5965(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5965[]; - static x64Token tokenBranches5966[]; - static x64Token tokenBranches5967[]; - static x64Token tokenBranches5968[]; - static x64Token tokenBranches5969[]; - static x64Token tokenBranches5970[]; - static x64Token tokenBranches5971[]; - static x64Token tokenBranches5972[]; - static x64Token tokenBranches5973[]; - static x64Token tokenBranches5974[]; - void TokenFunc5975(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5980[]; - static x64Token tokenBranches5981[]; - static x64Token tokenBranches5982[]; - static x64Token tokenBranches5983[]; - static x64Token tokenBranches5984[]; - static x64Token tokenBranches5985[]; - static x64Token tokenBranches5986[]; - static x64Token tokenBranches5987[]; - void TokenFunc5988(x64Operand& operand, int tokenPos); - static x64Token tokenBranches5993[]; - static x64Token tokenBranches5994[]; - static x64Token tokenBranches5995[]; - static x64Token tokenBranches5996[]; - static x64Token tokenBranches5997[]; - static x64Token tokenBranches5998[]; - static x64Token tokenBranches5999[]; - static x64Token tokenBranches6000[]; - void TokenFunc6001(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6004[]; - static x64Token tokenBranches6005[]; - static x64Token tokenBranches6006[]; - static x64Token tokenBranches6007[]; - static x64Token tokenBranches6008[]; - static x64Token tokenBranches6009[]; - void TokenFunc6010(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6015[]; - static x64Token tokenBranches6016[]; - static x64Token tokenBranches6017[]; - static x64Token tokenBranches6018[]; - static x64Token tokenBranches6019[]; - static x64Token tokenBranches6020[]; - static x64Token tokenBranches6021[]; - static x64Token tokenBranches6022[]; - void TokenFunc6023(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6024[]; - static x64Token tokenBranches6025[]; - static x64Token tokenBranches6026[]; - static x64Token tokenBranches6027[]; - static x64Token tokenBranches6028[]; - static x64Token tokenBranches6029[]; - static x64Token tokenBranches6030[]; - static x64Token tokenBranches6031[]; - static x64Token tokenBranches6032[]; - static x64Token tokenBranches6033[]; - static x64Token tokenBranches6034[]; - static x64Token tokenBranches6035[]; - void TokenFunc6036(x64Operand& operand, int tokenPos); - void TokenFunc6039(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6039[]; - static x64Token tokenBranches6040[]; - static x64Token tokenBranches6041[]; - static x64Token tokenBranches6042[]; - static x64Token tokenBranches6043[]; - static x64Token tokenBranches6044[]; - static x64Token tokenBranches6045[]; - static x64Token tokenBranches6046[]; - static x64Token tokenBranches6047[]; - static x64Token tokenBranches6048[]; - void TokenFunc6049(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6054[]; - static x64Token tokenBranches6055[]; - static x64Token tokenBranches6056[]; - static x64Token tokenBranches6057[]; - static x64Token tokenBranches6058[]; - static x64Token tokenBranches6059[]; - static x64Token tokenBranches6060[]; - static x64Token tokenBranches6061[]; - void TokenFunc6062(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6067[]; - static x64Token tokenBranches6068[]; - static x64Token tokenBranches6069[]; - static x64Token tokenBranches6070[]; - static x64Token tokenBranches6071[]; - static x64Token tokenBranches6072[]; - static x64Token tokenBranches6073[]; - static x64Token tokenBranches6074[]; - void TokenFunc6075(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6078[]; - static x64Token tokenBranches6079[]; - static x64Token tokenBranches6080[]; - static x64Token tokenBranches6081[]; - static x64Token tokenBranches6082[]; - static x64Token tokenBranches6083[]; - void TokenFunc6084(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6089[]; - static x64Token tokenBranches6090[]; - static x64Token tokenBranches6091[]; - static x64Token tokenBranches6092[]; - static x64Token tokenBranches6093[]; - static x64Token tokenBranches6094[]; - void TokenFunc6095(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6096[]; - static x64Token tokenBranches6097[]; - static x64Token tokenBranches6098[]; - static x64Token tokenBranches6099[]; - static x64Token tokenBranches6100[]; - static x64Token tokenBranches6101[]; - static x64Token tokenBranches6102[]; - static x64Token tokenBranches6103[]; - static x64Token tokenBranches6104[]; - static x64Token tokenBranches6105[]; - static x64Token tokenBranches6106[]; - static x64Token tokenBranches6107[]; - void TokenFunc6108(x64Operand& operand, int tokenPos); - void TokenFunc6111(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6111[]; - static x64Token tokenBranches6112[]; - static x64Token tokenBranches6113[]; - static x64Token tokenBranches6114[]; - static x64Token tokenBranches6115[]; - static x64Token tokenBranches6116[]; - static x64Token tokenBranches6117[]; - static x64Token tokenBranches6118[]; - static x64Token tokenBranches6119[]; - static x64Token tokenBranches6120[]; - void TokenFunc6121(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6126[]; - static x64Token tokenBranches6127[]; - static x64Token tokenBranches6128[]; - static x64Token tokenBranches6129[]; - static x64Token tokenBranches6130[]; - static x64Token tokenBranches6131[]; - static x64Token tokenBranches6132[]; - static x64Token tokenBranches6133[]; - void TokenFunc6134(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6139[]; - static x64Token tokenBranches6140[]; - static x64Token tokenBranches6141[]; - static x64Token tokenBranches6142[]; - static x64Token tokenBranches6143[]; - static x64Token tokenBranches6144[]; - static x64Token tokenBranches6145[]; - static x64Token tokenBranches6146[]; - void TokenFunc6147(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6150[]; - static x64Token tokenBranches6151[]; - static x64Token tokenBranches6152[]; - static x64Token tokenBranches6153[]; - static x64Token tokenBranches6154[]; - static x64Token tokenBranches6155[]; - void TokenFunc6156(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6161[]; - static x64Token tokenBranches6162[]; - static x64Token tokenBranches6163[]; - static x64Token tokenBranches6164[]; - static x64Token tokenBranches6165[]; - static x64Token tokenBranches6166[]; - void TokenFunc6167(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6168[]; - static x64Token tokenBranches6169[]; - static x64Token tokenBranches6170[]; - static x64Token tokenBranches6171[]; - static x64Token tokenBranches6172[]; - static x64Token tokenBranches6173[]; - static x64Token tokenBranches6174[]; - static x64Token tokenBranches6175[]; - static x64Token tokenBranches6176[]; - static x64Token tokenBranches6177[]; - static x64Token tokenBranches6178[]; - static x64Token tokenBranches6179[]; - void TokenFunc6180(x64Operand& operand, int tokenPos); - void TokenFunc6183(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6183[]; - static x64Token tokenBranches6184[]; - static x64Token tokenBranches6185[]; - static x64Token tokenBranches6186[]; - static x64Token tokenBranches6187[]; - static x64Token tokenBranches6188[]; - static x64Token tokenBranches6189[]; - static x64Token tokenBranches6190[]; - static x64Token tokenBranches6191[]; - static x64Token tokenBranches6192[]; - void TokenFunc6193(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6196[]; - static x64Token tokenBranches6197[]; - static x64Token tokenBranches6198[]; - static x64Token tokenBranches6199[]; - static x64Token tokenBranches6200[]; - static x64Token tokenBranches6201[]; - void TokenFunc6202(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6207[]; - static x64Token tokenBranches6208[]; - static x64Token tokenBranches6209[]; - static x64Token tokenBranches6210[]; - static x64Token tokenBranches6211[]; - static x64Token tokenBranches6212[]; - void TokenFunc6213(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6217[]; - void TokenFunc6218(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6219[]; - static x64Token tokenBranches6220[]; - static x64Token tokenBranches6221[]; - static x64Token tokenBranches6222[]; - static Coding tokenCoding6223_16[]; - static Coding tokenCoding6223_17[]; - static Coding tokenCoding6223_18[]; - static Coding tokenCoding6223_19[]; - void TokenFunc6223(x64Operand& operand, int tokenPos); - static Coding tokenCoding6227_16[]; - static Coding tokenCoding6227_17[]; - static Coding tokenCoding6227_23[]; - static Coding tokenCoding6227_18[]; - static Coding tokenCoding6227_19[]; - void TokenFunc6227(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6228[]; - static x64Token tokenBranches6229[]; - static x64Token tokenBranches6230[]; - static Coding tokenCoding6231_16[]; - static Coding tokenCoding6231_17[]; - static Coding tokenCoding6231_18[]; - static Coding tokenCoding6231_19[]; - void TokenFunc6231(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6232[]; - static x64Token tokenBranches6233[]; - static x64Token tokenBranches6234[]; - static Coding tokenCoding6235_16[]; - static Coding tokenCoding6235_17[]; - static Coding tokenCoding6235_18[]; - static Coding tokenCoding6235_19[]; - void TokenFunc6235(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6236[]; - static x64Token tokenBranches6237[]; - static x64Token tokenBranches6238[]; - static Coding tokenCoding6239_16[]; - static Coding tokenCoding6239_17[]; - static Coding tokenCoding6239_18[]; - static Coding tokenCoding6239_19[]; - void TokenFunc6239(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6240[]; - static Coding tokenCoding6241_16[]; - static Coding tokenCoding6241_17[]; - static Coding tokenCoding6241_18[]; - static Coding tokenCoding6241_19[]; - void TokenFunc6241(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6242[]; - static Coding tokenCoding6243_16[]; - static Coding tokenCoding6243_17[]; - static Coding tokenCoding6243_18[]; - static Coding tokenCoding6243_19[]; - void TokenFunc6243(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6245[]; - void TokenFunc6246(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6253[]; - static x64Token tokenBranches6254[]; - void TokenFunc6255(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6255[]; - static x64Token tokenBranches6256[]; - static x64Token tokenBranches6257[]; - void TokenFunc6258(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6259[]; - void TokenFunc6260(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6260[]; - static x64Token tokenBranches6261[]; - static Coding tokenCoding6262_16[]; - static Coding tokenCoding6262_17[]; - static Coding tokenCoding6262_18[]; - static Coding tokenCoding6262_19[]; - void TokenFunc6262(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6272[]; - static x64Token tokenBranches6273[]; - static x64Token tokenBranches6274[]; - void TokenFunc6275(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6276[]; - static x64Token tokenBranches6277[]; - static x64Token tokenBranches6278[]; - void TokenFunc6279(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6280[]; - static x64Token tokenBranches6281[]; - static x64Token tokenBranches6282[]; - void TokenFunc6283(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6284[]; - static x64Token tokenBranches6285[]; - static x64Token tokenBranches6286[]; - void TokenFunc6287(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6288[]; - static x64Token tokenBranches6289[]; - static x64Token tokenBranches6290[]; - void TokenFunc6291(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6292[]; - static x64Token tokenBranches6293[]; - static x64Token tokenBranches6294[]; - void TokenFunc6295(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6296[]; - static x64Token tokenBranches6297[]; - static x64Token tokenBranches6298[]; - void TokenFunc6299(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6300[]; - static x64Token tokenBranches6301[]; - static x64Token tokenBranches6302[]; - void TokenFunc6303(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6304[]; - static x64Token tokenBranches6305[]; - static x64Token tokenBranches6306[]; - void TokenFunc6307(x64Operand& operand, int tokenPos); - void TokenFunc6308(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6309[]; - static Coding tokenCoding6310_16[]; - static Coding tokenCoding6310_17[]; - static Coding tokenCoding6310_19[]; - void TokenFunc6310(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6311[]; - static Coding tokenCoding6312_16[]; - static Coding tokenCoding6312_17[]; - static Coding tokenCoding6312_19[]; - void TokenFunc6312(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6313[]; - static x64Token tokenBranches6314[]; - static x64Token tokenBranches6315[]; - void TokenFunc6316(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6317[]; - static x64Token tokenBranches6318[]; - static x64Token tokenBranches6319[]; - void TokenFunc6320(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6321[]; - void TokenFunc6322(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6323[]; - static Coding tokenCoding6324_16[]; - static Coding tokenCoding6324_17[]; - static Coding tokenCoding6324_19[]; - void TokenFunc6324(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6325[]; - static Coding tokenCoding6326_16[]; - static Coding tokenCoding6326_17[]; - static Coding tokenCoding6326_19[]; - void TokenFunc6326(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6336[]; - static Coding tokenCoding6337_18[]; - static Coding tokenCoding6337_19[]; - void TokenFunc6337(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6338[]; - static Coding tokenCoding6339_18[]; - static Coding tokenCoding6339_19[]; - void TokenFunc6339(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6345[]; - static x64Token tokenBranches6346[]; - static Coding tokenCoding6347_16[]; - static Coding tokenCoding6347_17[]; - static Coding tokenCoding6347_18[]; - static Coding tokenCoding6347_19[]; - void TokenFunc6347(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6348[]; - static Coding tokenCoding6349_16[]; - static Coding tokenCoding6349_17[]; - static Coding tokenCoding6349_18[]; - static Coding tokenCoding6349_19[]; - void TokenFunc6349(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6350[]; - static Coding tokenCoding6351_16[]; - static Coding tokenCoding6351_17[]; - static Coding tokenCoding6351_18[]; - static Coding tokenCoding6351_19[]; - void TokenFunc6351(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6357[]; - static x64Token tokenBranches6358[]; - static Coding tokenCoding6359_16[]; - static Coding tokenCoding6359_17[]; - static Coding tokenCoding6359_18[]; - static Coding tokenCoding6359_19[]; - void TokenFunc6359(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6360[]; - static Coding tokenCoding6361_16[]; - static Coding tokenCoding6361_17[]; - static Coding tokenCoding6361_18[]; - static Coding tokenCoding6361_19[]; - void TokenFunc6361(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6364[]; - static Coding tokenCoding6365_18[]; - static Coding tokenCoding6365_19[]; - void TokenFunc6365(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6366[]; - static Coding tokenCoding6367_16[]; - static Coding tokenCoding6367_17[]; - static Coding tokenCoding6367_18[]; - static Coding tokenCoding6367_19[]; - void TokenFunc6367(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6368[]; - static Coding tokenCoding6369_16[]; - static Coding tokenCoding6369_17[]; - static Coding tokenCoding6369_18[]; - static Coding tokenCoding6369_19[]; - void TokenFunc6369(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6370[]; - static Coding tokenCoding6371_16[]; - static Coding tokenCoding6371_17[]; - static Coding tokenCoding6371_18[]; - static Coding tokenCoding6371_19[]; - void TokenFunc6371(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6373[]; - static x64Token tokenBranches6374[]; - static Coding tokenCoding6375_16[]; - static Coding tokenCoding6375_17[]; - static Coding tokenCoding6375_18[]; - static Coding tokenCoding6375_19[]; - void TokenFunc6375(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6376[]; - static Coding tokenCoding6377_16[]; - static Coding tokenCoding6377_17[]; - static Coding tokenCoding6377_18[]; - static Coding tokenCoding6377_19[]; - void TokenFunc6377(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6387[]; - static Coding tokenCoding6388_16[]; - static Coding tokenCoding6388_17[]; - static Coding tokenCoding6388_18[]; - static Coding tokenCoding6388_19[]; - void TokenFunc6388(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6394[]; - static Coding tokenCoding6395_16[]; - static Coding tokenCoding6395_17[]; - static Coding tokenCoding6395_18[]; - static Coding tokenCoding6395_19[]; - void TokenFunc6395(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6396[]; - static Coding tokenCoding6397_16[]; - static Coding tokenCoding6397_17[]; - static Coding tokenCoding6397_18[]; - static Coding tokenCoding6397_19[]; - void TokenFunc6397(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6403[]; - static Coding tokenCoding6404_18[]; - static Coding tokenCoding6404_19[]; - void TokenFunc6404(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6405[]; - static Coding tokenCoding6406_16[]; - static Coding tokenCoding6406_17[]; - static Coding tokenCoding6406_18[]; - static Coding tokenCoding6406_19[]; - void TokenFunc6406(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6407[]; - static Coding tokenCoding6408_16[]; - static Coding tokenCoding6408_17[]; - static Coding tokenCoding6408_18[]; - static Coding tokenCoding6408_19[]; - void TokenFunc6408(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6409[]; - static x64Token tokenBranches6410[]; - static Coding tokenCoding6411_16[]; - static Coding tokenCoding6411_17[]; - static Coding tokenCoding6411_18[]; - static Coding tokenCoding6411_19[]; - void TokenFunc6411(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6412[]; - static x64Token tokenBranches6413[]; - static Coding tokenCoding6414_16[]; - static Coding tokenCoding6414_17[]; - static Coding tokenCoding6414_18[]; - static Coding tokenCoding6414_19[]; - void TokenFunc6414(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6415[]; - static Coding tokenCoding6416_16[]; - static Coding tokenCoding6416_17[]; - static Coding tokenCoding6416_18[]; - static Coding tokenCoding6416_19[]; - void TokenFunc6416(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6417[]; - static Coding tokenCoding6418_16[]; - static Coding tokenCoding6418_17[]; - static Coding tokenCoding6418_18[]; - static Coding tokenCoding6418_19[]; - void TokenFunc6418(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6419[]; - static Coding tokenCoding6420_18[]; - static Coding tokenCoding6420_19[]; - void TokenFunc6420(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6421[]; - static Coding tokenCoding6422_16[]; - static Coding tokenCoding6422_17[]; - static Coding tokenCoding6422_18[]; - static Coding tokenCoding6422_19[]; - void TokenFunc6422(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6423[]; - static Coding tokenCoding6424_16[]; - static Coding tokenCoding6424_17[]; - static Coding tokenCoding6424_18[]; - static Coding tokenCoding6424_19[]; - void TokenFunc6424(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6425[]; - static Coding tokenCoding6426_16[]; - static Coding tokenCoding6426_17[]; - static Coding tokenCoding6426_18[]; - static Coding tokenCoding6426_19[]; - void TokenFunc6426(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6427[]; - static x64Token tokenBranches6428[]; - static Coding tokenCoding6429_16[]; - static Coding tokenCoding6429_17[]; - static Coding tokenCoding6429_18[]; - static Coding tokenCoding6429_19[]; - void TokenFunc6429(x64Operand& operand, int tokenPos); - void TokenFunc6430(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6431[]; - static x64Token tokenBranches6432[]; - static Coding tokenCoding6433_16[]; - static Coding tokenCoding6433_17[]; - static Coding tokenCoding6433_18[]; - static Coding tokenCoding6433_19[]; - void TokenFunc6433(x64Operand& operand, int tokenPos); - void TokenFunc6434(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6441[]; - static x64Token tokenBranches6442[]; - static x64Token tokenBranches6443[]; - void TokenFunc6444(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6445[]; - static x64Token tokenBranches6446[]; - static x64Token tokenBranches6447[]; - void TokenFunc6448(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6454[]; - static x64Token tokenBranches6455[]; - static x64Token tokenBranches6456[]; - void TokenFunc6457(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6458[]; - static x64Token tokenBranches6459[]; - static x64Token tokenBranches6460[]; - void TokenFunc6461(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6462[]; - static Coding tokenCoding6463_16[]; - static Coding tokenCoding6463_17[]; - static Coding tokenCoding6463_18[]; - static Coding tokenCoding6463_19[]; - void TokenFunc6463(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6464[]; - static Coding tokenCoding6465_16[]; - static Coding tokenCoding6465_17[]; - static Coding tokenCoding6465_18[]; - static Coding tokenCoding6465_19[]; - void TokenFunc6465(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6472[]; - void TokenFunc6473(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6473[]; - static x64Token tokenBranches6474[]; - static x64Token tokenBranches6475[]; - void TokenFunc6476(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6479[]; - void TokenFunc6480(x64Operand& operand, int tokenPos); - void TokenFunc6481(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6481[]; - static x64Token tokenBranches6482[]; - static x64Token tokenBranches6483[]; - void TokenFunc6484(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6487[]; - void TokenFunc6488(x64Operand& operand, int tokenPos); - void TokenFunc6489(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6489[]; - static x64Token tokenBranches6490[]; - static x64Token tokenBranches6491[]; - void TokenFunc6492(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6495[]; - void TokenFunc6496(x64Operand& operand, int tokenPos); - static Coding tokenCoding6500_16[]; - static Coding tokenCoding6500_17[]; - static Coding tokenCoding6500_18[]; - static Coding tokenCoding6500_19[]; - void TokenFunc6500(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6500[]; - static x64Token tokenBranches6501[]; - static x64Token tokenBranches6502[]; - static Coding tokenCoding6503_16[]; - static Coding tokenCoding6503_17[]; - static Coding tokenCoding6503_18[]; - static Coding tokenCoding6503_19[]; - void TokenFunc6503(x64Operand& operand, int tokenPos); - static Coding tokenCoding6509_16[]; - static Coding tokenCoding6509_17[]; - static Coding tokenCoding6509_18[]; - static Coding tokenCoding6509_19[]; - void TokenFunc6509(x64Operand& operand, int tokenPos); - static Coding tokenCoding6517_16[]; - static Coding tokenCoding6517_17[]; - static Coding tokenCoding6517_18[]; - static Coding tokenCoding6517_19[]; - void TokenFunc6517(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6517[]; - static x64Token tokenBranches6518[]; - static x64Token tokenBranches6519[]; - static Coding tokenCoding6520_16[]; - static Coding tokenCoding6520_17[]; - static Coding tokenCoding6520_18[]; - static Coding tokenCoding6520_19[]; - void TokenFunc6520(x64Operand& operand, int tokenPos); - static Coding tokenCoding6526_16[]; - static Coding tokenCoding6526_17[]; - static Coding tokenCoding6526_18[]; - static Coding tokenCoding6526_19[]; - void TokenFunc6526(x64Operand& operand, int tokenPos); - static Coding tokenCoding6534_16[]; - static Coding tokenCoding6534_17[]; - static Coding tokenCoding6534_18[]; - static Coding tokenCoding6534_19[]; - void TokenFunc6534(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6534[]; - static x64Token tokenBranches6535[]; - static x64Token tokenBranches6536[]; - static Coding tokenCoding6537_16[]; - static Coding tokenCoding6537_17[]; - static Coding tokenCoding6537_18[]; - static Coding tokenCoding6537_19[]; - void TokenFunc6537(x64Operand& operand, int tokenPos); - static Coding tokenCoding6543_16[]; - static Coding tokenCoding6543_17[]; - static Coding tokenCoding6543_18[]; - static Coding tokenCoding6543_19[]; - void TokenFunc6543(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6548[]; - static Coding tokenCoding6549_16[]; - static Coding tokenCoding6549_17[]; - static Coding tokenCoding6549_18[]; - static Coding tokenCoding6549_19[]; - void TokenFunc6549(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6550[]; - static Coding tokenCoding6551_16[]; - static Coding tokenCoding6551_17[]; - static Coding tokenCoding6551_18[]; - static Coding tokenCoding6551_19[]; - void TokenFunc6551(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6552[]; - static Coding tokenCoding6553_16[]; - static Coding tokenCoding6553_17[]; - static Coding tokenCoding6553_18[]; - static Coding tokenCoding6553_19[]; - void TokenFunc6553(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6554[]; - static Coding tokenCoding6555_16[]; - static Coding tokenCoding6555_17[]; - static Coding tokenCoding6555_18[]; - static Coding tokenCoding6555_19[]; - void TokenFunc6555(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6556[]; - static x64Token tokenBranches6557[]; - static x64Token tokenBranches6558[]; - static x64Token tokenBranches6559[]; - void TokenFunc6560(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6561[]; - static x64Token tokenBranches6562[]; - static x64Token tokenBranches6563[]; - void TokenFunc6564(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6565[]; - static x64Token tokenBranches6566[]; - static x64Token tokenBranches6567[]; - void TokenFunc6568(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6569[]; - static x64Token tokenBranches6570[]; - static x64Token tokenBranches6571[]; - void TokenFunc6572(x64Operand& operand, int tokenPos); - void TokenFunc6575(x64Operand& operand, int tokenPos); - void TokenFunc6578(x64Operand& operand, int tokenPos); - void TokenFunc6581(x64Operand& operand, int tokenPos); - void TokenFunc6584(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6585[]; - static x64Token tokenBranches6586[]; - static x64Token tokenBranches6587[]; - static x64Token tokenBranches6588[]; - static x64Token tokenBranches6589[]; - static x64Token tokenBranches6590[]; - static x64Token tokenBranches6591[]; - static x64Token tokenBranches6592[]; - void TokenFunc6593(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6595[]; - void TokenFunc6596(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6596[]; - static x64Token tokenBranches6597[]; - static x64Token tokenBranches6598[]; - static x64Token tokenBranches6599[]; - static x64Token tokenBranches6600[]; - void TokenFunc6601(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6606[]; - static x64Token tokenBranches6607[]; - static x64Token tokenBranches6608[]; - void TokenFunc6609(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6614[]; - static x64Token tokenBranches6615[]; - static x64Token tokenBranches6616[]; - void TokenFunc6617(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6620[]; - static x64Token tokenBranches6621[]; - static x64Token tokenBranches6622[]; - void TokenFunc6623(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6628[]; - static x64Token tokenBranches6629[]; - static x64Token tokenBranches6630[]; - void TokenFunc6631(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6632[]; - static x64Token tokenBranches6633[]; - static x64Token tokenBranches6634[]; - static x64Token tokenBranches6635[]; - static x64Token tokenBranches6636[]; - static x64Token tokenBranches6637[]; - static x64Token tokenBranches6638[]; - void TokenFunc6639(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6641[]; - void TokenFunc6642(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6642[]; - static x64Token tokenBranches6643[]; - static x64Token tokenBranches6644[]; - static x64Token tokenBranches6645[]; - static x64Token tokenBranches6646[]; - void TokenFunc6647(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6652[]; - static x64Token tokenBranches6653[]; - static x64Token tokenBranches6654[]; - void TokenFunc6655(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6660[]; - static x64Token tokenBranches6661[]; - static x64Token tokenBranches6662[]; - void TokenFunc6663(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6666[]; - static x64Token tokenBranches6667[]; - static x64Token tokenBranches6668[]; - void TokenFunc6669(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6674[]; - static x64Token tokenBranches6675[]; - static x64Token tokenBranches6676[]; - void TokenFunc6677(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6678[]; - static x64Token tokenBranches6679[]; - static x64Token tokenBranches6680[]; - static x64Token tokenBranches6681[]; - static x64Token tokenBranches6682[]; - static x64Token tokenBranches6683[]; - static x64Token tokenBranches6684[]; - void TokenFunc6685(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6687[]; - void TokenFunc6688(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6688[]; - static x64Token tokenBranches6689[]; - static x64Token tokenBranches6690[]; - static x64Token tokenBranches6691[]; - static x64Token tokenBranches6692[]; - void TokenFunc6693(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6698[]; - static x64Token tokenBranches6699[]; - static x64Token tokenBranches6700[]; - void TokenFunc6701(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6706[]; - static x64Token tokenBranches6707[]; - static x64Token tokenBranches6708[]; - void TokenFunc6709(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6712[]; - static x64Token tokenBranches6713[]; - static x64Token tokenBranches6714[]; - void TokenFunc6715(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6720[]; - static x64Token tokenBranches6721[]; - static x64Token tokenBranches6722[]; - void TokenFunc6723(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6728[]; - static x64Token tokenBranches6729[]; - void TokenFunc6730(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6735[]; - static Coding tokenCoding6736_16[]; - static Coding tokenCoding6736_17[]; - static Coding tokenCoding6736_18[]; - static Coding tokenCoding6736_19[]; - void TokenFunc6736(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6739[]; - void TokenFunc6740(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6747[]; - void TokenFunc6748(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6749[]; - void TokenFunc6750(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6756[]; - static x64Token tokenBranches6757[]; - void TokenFunc6758(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6758[]; - static x64Token tokenBranches6759[]; - static x64Token tokenBranches6760[]; - void TokenFunc6761(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6765[]; - void TokenFunc6766(x64Operand& operand, int tokenPos); - void TokenFunc6768(x64Operand& operand, int tokenPos); - void TokenFunc6770(x64Operand& operand, int tokenPos); - static Coding tokenCoding6772_16[]; - static Coding tokenCoding6772_17[]; - static Coding tokenCoding6772_18[]; - static Coding tokenCoding6772_19[]; - void TokenFunc6772(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6774[]; - static Coding tokenCoding6775_16[]; - static Coding tokenCoding6775_17[]; - static Coding tokenCoding6775_18[]; - static Coding tokenCoding6775_19[]; - void TokenFunc6775(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6777[]; - static Coding tokenCoding6778_16[]; - static Coding tokenCoding6778_17[]; - static Coding tokenCoding6778_18[]; - static Coding tokenCoding6778_19[]; - void TokenFunc6778(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6779[]; - void TokenFunc6780(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6781[]; - void TokenFunc6782(x64Operand& operand, int tokenPos); - void TokenFunc6784(x64Operand& operand, int tokenPos); - void TokenFunc6785(x64Operand& operand, int tokenPos); - void TokenFunc6786(x64Operand& operand, int tokenPos); - static Coding tokenCoding6787_16[]; - static Coding tokenCoding6787_17[]; - static Coding tokenCoding6787_18[]; - static Coding tokenCoding6787_19[]; - void TokenFunc6787(x64Operand& operand, int tokenPos); - static Coding tokenCoding6788_16[]; - static Coding tokenCoding6788_17[]; - static Coding tokenCoding6788_18[]; - static Coding tokenCoding6788_19[]; - void TokenFunc6788(x64Operand& operand, int tokenPos); - static Coding tokenCoding6789_16[]; - static Coding tokenCoding6789_17[]; - static Coding tokenCoding6789_18[]; - static Coding tokenCoding6789_19[]; - void TokenFunc6789(x64Operand& operand, int tokenPos); - static Coding tokenCoding6790_16[]; - static Coding tokenCoding6790_17[]; - static Coding tokenCoding6790_18[]; - static Coding tokenCoding6790_19[]; - void TokenFunc6790(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6791[]; - static Coding tokenCoding6792_16[]; - static Coding tokenCoding6792_17[]; - static Coding tokenCoding6792_18[]; - static Coding tokenCoding6792_19[]; - void TokenFunc6792(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6793[]; - static Coding tokenCoding6794_16[]; - static Coding tokenCoding6794_17[]; - static Coding tokenCoding6794_18[]; - static Coding tokenCoding6794_19[]; - void TokenFunc6794(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6795[]; - static Coding tokenCoding6796_16[]; - static Coding tokenCoding6796_17[]; - static Coding tokenCoding6796_18[]; - static Coding tokenCoding6796_19[]; - void TokenFunc6796(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6829[]; - static Coding tokenCoding6830_16[]; - static Coding tokenCoding6830_17[]; - static Coding tokenCoding6830_18[]; - static Coding tokenCoding6830_19[]; - void TokenFunc6830(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6831[]; - static x64Token tokenBranches6832[]; - static x64Token tokenBranches6833[]; - static x64Token tokenBranches6834[]; - static x64Token tokenBranches6835[]; - static x64Token tokenBranches6836[]; - void TokenFunc6837(x64Operand& operand, int tokenPos); - void TokenFunc6840(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6840[]; - static x64Token tokenBranches6841[]; - static x64Token tokenBranches6842[]; - void TokenFunc6843(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6848[]; - void TokenFunc6849(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6854[]; - void TokenFunc6855(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6858[]; - void TokenFunc6859(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6864[]; - void TokenFunc6865(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6866[]; - static x64Token tokenBranches6867[]; - static x64Token tokenBranches6868[]; - static x64Token tokenBranches6869[]; - static x64Token tokenBranches6870[]; - void TokenFunc6871(x64Operand& operand, int tokenPos); - void TokenFunc6874(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6874[]; - static x64Token tokenBranches6875[]; - static x64Token tokenBranches6876[]; - void TokenFunc6877(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6882[]; - void TokenFunc6883(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6888[]; - void TokenFunc6889(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6892[]; - void TokenFunc6893(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6898[]; - void TokenFunc6899(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6900[]; - static x64Token tokenBranches6901[]; - static x64Token tokenBranches6902[]; - static x64Token tokenBranches6903[]; - static x64Token tokenBranches6904[]; - void TokenFunc6905(x64Operand& operand, int tokenPos); - void TokenFunc6908(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6908[]; - static x64Token tokenBranches6909[]; - static x64Token tokenBranches6910[]; - void TokenFunc6911(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6916[]; - void TokenFunc6917(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6922[]; - void TokenFunc6923(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6926[]; - void TokenFunc6927(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6932[]; - void TokenFunc6933(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6934[]; - static x64Token tokenBranches6935[]; - static x64Token tokenBranches6936[]; - static x64Token tokenBranches6937[]; - static x64Token tokenBranches6938[]; - void TokenFunc6939(x64Operand& operand, int tokenPos); - void TokenFunc6942(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6942[]; - static x64Token tokenBranches6943[]; - static x64Token tokenBranches6944[]; - void TokenFunc6945(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6948[]; - void TokenFunc6949(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6954[]; - void TokenFunc6955(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6959[]; - void TokenFunc6960(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6961[]; - void TokenFunc6962(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6963[]; - void TokenFunc6964(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6965[]; - void TokenFunc6966(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6967[]; - void TokenFunc6968(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6969[]; - void TokenFunc6970(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6973[]; - static Coding tokenCoding6974_16[]; - static Coding tokenCoding6974_17[]; - static Coding tokenCoding6974_18[]; - static Coding tokenCoding6974_19[]; - void TokenFunc6974(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6975[]; - void TokenFunc6976(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6976[]; - static x64Token tokenBranches6977[]; - static Coding tokenCoding6978_16[]; - static Coding tokenCoding6978_17[]; - static Coding tokenCoding6978_18[]; - static Coding tokenCoding6978_19[]; - void TokenFunc6978(x64Operand& operand, int tokenPos); - void TokenFunc6979(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6979[]; - static x64Token tokenBranches6980[]; - static Coding tokenCoding6981_16[]; - static Coding tokenCoding6981_17[]; - static Coding tokenCoding6981_18[]; - static Coding tokenCoding6981_19[]; - void TokenFunc6981(x64Operand& operand, int tokenPos); - void TokenFunc6982(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6982[]; - static x64Token tokenBranches6983[]; - static Coding tokenCoding6984_16[]; - static Coding tokenCoding6984_17[]; - static Coding tokenCoding6984_18[]; - static Coding tokenCoding6984_19[]; - void TokenFunc6984(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6985[]; - static x64Token tokenBranches6986[]; - static x64Token tokenBranches6987[]; - static x64Token tokenBranches6988[]; - void TokenFunc6989(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6989[]; - void TokenFunc6990(x64Operand& operand, int tokenPos); - void TokenFunc6995(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6995[]; - static x64Token tokenBranches6996[]; - void TokenFunc6997(x64Operand& operand, int tokenPos); - static x64Token tokenBranches6997[]; - void TokenFunc6998(x64Operand& operand, int tokenPos); - void TokenFunc7003(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7003[]; - void TokenFunc7004(x64Operand& operand, int tokenPos); - void TokenFunc7011(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7011[]; - void TokenFunc7012(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7013[]; - static x64Token tokenBranches7014[]; - static x64Token tokenBranches7015[]; - static x64Token tokenBranches7016[]; - void TokenFunc7017(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7017[]; - void TokenFunc7018(x64Operand& operand, int tokenPos); - void TokenFunc7023(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7023[]; - static x64Token tokenBranches7024[]; - void TokenFunc7025(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7025[]; - void TokenFunc7026(x64Operand& operand, int tokenPos); - void TokenFunc7031(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7031[]; - void TokenFunc7032(x64Operand& operand, int tokenPos); - void TokenFunc7039(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7039[]; - void TokenFunc7040(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7041[]; - static x64Token tokenBranches7042[]; - static x64Token tokenBranches7043[]; - static x64Token tokenBranches7044[]; - void TokenFunc7045(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7045[]; - void TokenFunc7046(x64Operand& operand, int tokenPos); - void TokenFunc7051(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7051[]; - static x64Token tokenBranches7052[]; - void TokenFunc7053(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7053[]; - void TokenFunc7054(x64Operand& operand, int tokenPos); - void TokenFunc7059(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7059[]; - void TokenFunc7060(x64Operand& operand, int tokenPos); - void TokenFunc7067(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7067[]; - void TokenFunc7068(x64Operand& operand, int tokenPos); - void TokenFunc7069(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7069[]; - static x64Token tokenBranches7070[]; - static x64Token tokenBranches7071[]; - void TokenFunc7072(x64Operand& operand, int tokenPos); - void TokenFunc7073(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7073[]; - static x64Token tokenBranches7074[]; - static x64Token tokenBranches7075[]; - void TokenFunc7076(x64Operand& operand, int tokenPos); - void TokenFunc7077(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7077[]; - static x64Token tokenBranches7078[]; - static x64Token tokenBranches7079[]; - void TokenFunc7080(x64Operand& operand, int tokenPos); - void TokenFunc7081(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7081[]; - static x64Token tokenBranches7082[]; - static x64Token tokenBranches7083[]; - void TokenFunc7084(x64Operand& operand, int tokenPos); - void TokenFunc7085(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7085[]; - static x64Token tokenBranches7086[]; - static x64Token tokenBranches7087[]; - void TokenFunc7088(x64Operand& operand, int tokenPos); - static Coding tokenCoding7092_16[]; - static Coding tokenCoding7092_17[]; - static Coding tokenCoding7092_18[]; - static Coding tokenCoding7092_19[]; - void TokenFunc7092(x64Operand& operand, int tokenPos); - static Coding tokenCoding7096_16[]; - static Coding tokenCoding7096_17[]; - static Coding tokenCoding7096_23[]; - static Coding tokenCoding7096_18[]; - static Coding tokenCoding7096_19[]; - void TokenFunc7096(x64Operand& operand, int tokenPos); - static Coding tokenCoding7100_16[]; - static Coding tokenCoding7100_17[]; - static Coding tokenCoding7100_18[]; - static Coding tokenCoding7100_19[]; - void TokenFunc7100(x64Operand& operand, int tokenPos); - static Coding tokenCoding7104_16[]; - static Coding tokenCoding7104_17[]; - static Coding tokenCoding7104_18[]; - static Coding tokenCoding7104_19[]; - void TokenFunc7104(x64Operand& operand, int tokenPos); - static Coding tokenCoding7108_16[]; - static Coding tokenCoding7108_17[]; - static Coding tokenCoding7108_18[]; - static Coding tokenCoding7108_19[]; - void TokenFunc7108(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7109[]; - static x64Token tokenBranches7110[]; - static x64Token tokenBranches7111[]; - static x64Token tokenBranches7112[]; - static Coding tokenCoding7113_16[]; - static Coding tokenCoding7113_17[]; - static Coding tokenCoding7113_18[]; - static Coding tokenCoding7113_19[]; - void TokenFunc7113(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7114[]; - static x64Token tokenBranches7115[]; - static x64Token tokenBranches7116[]; - static x64Token tokenBranches7117[]; - static Coding tokenCoding7118_16[]; - static Coding tokenCoding7118_17[]; - static Coding tokenCoding7118_18[]; - static Coding tokenCoding7118_19[]; - void TokenFunc7118(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7119[]; - static x64Token tokenBranches7120[]; - static x64Token tokenBranches7121[]; - static x64Token tokenBranches7122[]; - static Coding tokenCoding7123_16[]; - static Coding tokenCoding7123_17[]; - static Coding tokenCoding7123_18[]; - static Coding tokenCoding7123_19[]; - void TokenFunc7123(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7124[]; - static x64Token tokenBranches7125[]; - static x64Token tokenBranches7126[]; - static x64Token tokenBranches7127[]; - static Coding tokenCoding7128_16[]; - static Coding tokenCoding7128_17[]; - static Coding tokenCoding7128_18[]; - static Coding tokenCoding7128_19[]; - void TokenFunc7128(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7129[]; - static x64Token tokenBranches7130[]; - static Coding tokenCoding7131_16[]; - static Coding tokenCoding7131_17[]; - static Coding tokenCoding7131_18[]; - static Coding tokenCoding7131_19[]; - void TokenFunc7131(x64Operand& operand, int tokenPos); - static Coding tokenCoding7134_16[]; - static Coding tokenCoding7134_17[]; - static Coding tokenCoding7134_18[]; - static Coding tokenCoding7134_19[]; - void TokenFunc7134(x64Operand& operand, int tokenPos); - static Coding tokenCoding7137_16[]; - static Coding tokenCoding7137_17[]; - static Coding tokenCoding7137_18[]; - static Coding tokenCoding7137_19[]; - void TokenFunc7137(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7138[]; - static x64Token tokenBranches7139[]; - void TokenFunc7140(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7140[]; - static x64Token tokenBranches7141[]; - static x64Token tokenBranches7142[]; - void TokenFunc7143(x64Operand& operand, int tokenPos); - void TokenFunc7146(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7146[]; - static x64Token tokenBranches7147[]; - void TokenFunc7148(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7148[]; - static x64Token tokenBranches7149[]; - static x64Token tokenBranches7150[]; - void TokenFunc7151(x64Operand& operand, int tokenPos); - void TokenFunc7154(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7154[]; - static x64Token tokenBranches7155[]; - static x64Token tokenBranches7156[]; - void TokenFunc7157(x64Operand& operand, int tokenPos); - void TokenFunc7162(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7162[]; - static x64Token tokenBranches7163[]; - static x64Token tokenBranches7164[]; - void TokenFunc7165(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7166[]; - static x64Token tokenBranches7167[]; - void TokenFunc7168(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7168[]; - static x64Token tokenBranches7169[]; - static x64Token tokenBranches7170[]; - void TokenFunc7171(x64Operand& operand, int tokenPos); - void TokenFunc7174(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7174[]; - static x64Token tokenBranches7175[]; - void TokenFunc7176(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7176[]; - static x64Token tokenBranches7177[]; - static x64Token tokenBranches7178[]; - void TokenFunc7179(x64Operand& operand, int tokenPos); - void TokenFunc7182(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7182[]; - static x64Token tokenBranches7183[]; - static x64Token tokenBranches7184[]; - void TokenFunc7185(x64Operand& operand, int tokenPos); - void TokenFunc7190(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7190[]; - static x64Token tokenBranches7191[]; - static x64Token tokenBranches7192[]; - void TokenFunc7193(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7194[]; - static x64Token tokenBranches7195[]; - void TokenFunc7196(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7196[]; - static x64Token tokenBranches7197[]; - static x64Token tokenBranches7198[]; - void TokenFunc7199(x64Operand& operand, int tokenPos); - void TokenFunc7202(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7202[]; - static x64Token tokenBranches7203[]; - void TokenFunc7204(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7204[]; - static x64Token tokenBranches7205[]; - static x64Token tokenBranches7206[]; - void TokenFunc7207(x64Operand& operand, int tokenPos); - void TokenFunc7210(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7210[]; - static x64Token tokenBranches7211[]; - static x64Token tokenBranches7212[]; - void TokenFunc7213(x64Operand& operand, int tokenPos); - void TokenFunc7218(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7218[]; - static x64Token tokenBranches7219[]; - static x64Token tokenBranches7220[]; - void TokenFunc7221(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7223[]; - static x64Token tokenBranches7224[]; - static Coding tokenCoding7225_16[]; - static Coding tokenCoding7225_17[]; - static Coding tokenCoding7225_18[]; - static Coding tokenCoding7225_19[]; - void TokenFunc7225(x64Operand& operand, int tokenPos); - static Coding tokenCoding7229_16[]; - static Coding tokenCoding7229_17[]; - static Coding tokenCoding7229_23[]; - static Coding tokenCoding7229_18[]; - static Coding tokenCoding7229_19[]; - void TokenFunc7229(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7231[]; - static x64Token tokenBranches7232[]; - static Coding tokenCoding7233_16[]; - static Coding tokenCoding7233_17[]; - static Coding tokenCoding7233_18[]; - static Coding tokenCoding7233_19[]; - void TokenFunc7233(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7235[]; - static x64Token tokenBranches7236[]; - static Coding tokenCoding7237_16[]; - static Coding tokenCoding7237_17[]; - static Coding tokenCoding7237_18[]; - static Coding tokenCoding7237_19[]; - void TokenFunc7237(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7238[]; - static x64Token tokenBranches7239[]; - static x64Token tokenBranches7240[]; - static Coding tokenCoding7241_16[]; - static Coding tokenCoding7241_17[]; - static Coding tokenCoding7241_18[]; - static Coding tokenCoding7241_19[]; - void TokenFunc7241(x64Operand& operand, int tokenPos); - void TokenFunc7242(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7242[]; - static x64Token tokenBranches7243[]; - static x64Token tokenBranches7244[]; - static Coding tokenCoding7245_16[]; - static Coding tokenCoding7245_17[]; - static Coding tokenCoding7245_18[]; - static Coding tokenCoding7245_19[]; - void TokenFunc7245(x64Operand& operand, int tokenPos); - static Coding tokenCoding7248_16[]; - static Coding tokenCoding7248_17[]; - static Coding tokenCoding7248_18[]; - static Coding tokenCoding7248_19[]; - void TokenFunc7248(x64Operand& operand, int tokenPos); - static Coding tokenCoding7251_16[]; - static Coding tokenCoding7251_17[]; - static Coding tokenCoding7251_18[]; - static Coding tokenCoding7251_19[]; - void TokenFunc7251(x64Operand& operand, int tokenPos); - static Coding tokenCoding7254_16[]; - static Coding tokenCoding7254_17[]; - static Coding tokenCoding7254_18[]; - static Coding tokenCoding7254_19[]; - void TokenFunc7254(x64Operand& operand, int tokenPos); - static Coding tokenCoding7258_16[]; - static Coding tokenCoding7258_17[]; - static Coding tokenCoding7258_18[]; - static Coding tokenCoding7258_19[]; - void TokenFunc7258(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7259[]; - static x64Token tokenBranches7260[]; - static Coding tokenCoding7261_16[]; - static Coding tokenCoding7261_17[]; - static Coding tokenCoding7261_18[]; - static Coding tokenCoding7261_19[]; - void TokenFunc7261(x64Operand& operand, int tokenPos); - static Coding tokenCoding7264_16[]; - static Coding tokenCoding7264_17[]; - static Coding tokenCoding7264_18[]; - static Coding tokenCoding7264_19[]; - void TokenFunc7264(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7265[]; - static x64Token tokenBranches7266[]; - static Coding tokenCoding7267_16[]; - static Coding tokenCoding7267_17[]; - static Coding tokenCoding7267_18[]; - static Coding tokenCoding7267_19[]; - void TokenFunc7267(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7268[]; - static x64Token tokenBranches7269[]; - static x64Token tokenBranches7270[]; - static Coding tokenCoding7271_18[]; - static Coding tokenCoding7271_19[]; - void TokenFunc7271(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7274[]; - static Coding tokenCoding7275_18[]; - static Coding tokenCoding7275_19[]; - void TokenFunc7275(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7278[]; - static Coding tokenCoding7279_18[]; - static Coding tokenCoding7279_19[]; - void TokenFunc7279(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7282[]; - static Coding tokenCoding7283_18[]; - static Coding tokenCoding7283_19[]; - void TokenFunc7283(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7284[]; - static x64Token tokenBranches7285[]; - static x64Token tokenBranches7286[]; - static x64Token tokenBranches7287[]; - static x64Token tokenBranches7288[]; - static x64Token tokenBranches7289[]; - static x64Token tokenBranches7290[]; - static x64Token tokenBranches7291[]; - static x64Token tokenBranches7292[]; - static x64Token tokenBranches7293[]; - static x64Token tokenBranches7294[]; - static x64Token tokenBranches7295[]; - static x64Token tokenBranches7296[]; - void TokenFunc7297(x64Operand& operand, int tokenPos); - void TokenFunc7307(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7307[]; - static x64Token tokenBranches7308[]; - static x64Token tokenBranches7309[]; - void TokenFunc7310(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7315[]; - static x64Token tokenBranches7316[]; - static x64Token tokenBranches7317[]; - static x64Token tokenBranches7318[]; - static x64Token tokenBranches7319[]; - static x64Token tokenBranches7320[]; - static x64Token tokenBranches7321[]; - static x64Token tokenBranches7322[]; - void TokenFunc7323(x64Operand& operand, int tokenPos); - void TokenFunc7333(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7333[]; - static x64Token tokenBranches7334[]; - static x64Token tokenBranches7335[]; - void TokenFunc7336(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7338[]; - static x64Token tokenBranches7339[]; - static x64Token tokenBranches7340[]; - static x64Token tokenBranches7341[]; - static x64Token tokenBranches7342[]; - static x64Token tokenBranches7343[]; - static x64Token tokenBranches7344[]; - void TokenFunc7345(x64Operand& operand, int tokenPos); - void TokenFunc7353(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7353[]; - static x64Token tokenBranches7354[]; - static x64Token tokenBranches7355[]; - void TokenFunc7356(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7357[]; - static x64Token tokenBranches7358[]; - static x64Token tokenBranches7359[]; - static x64Token tokenBranches7360[]; - static x64Token tokenBranches7361[]; - static x64Token tokenBranches7362[]; - static x64Token tokenBranches7363[]; - static x64Token tokenBranches7364[]; - static x64Token tokenBranches7365[]; - static x64Token tokenBranches7366[]; - static x64Token tokenBranches7367[]; - static x64Token tokenBranches7368[]; - void TokenFunc7369(x64Operand& operand, int tokenPos); - void TokenFunc7379(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7379[]; - static x64Token tokenBranches7380[]; - static x64Token tokenBranches7381[]; - void TokenFunc7382(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7387[]; - static x64Token tokenBranches7388[]; - static x64Token tokenBranches7389[]; - static x64Token tokenBranches7390[]; - static x64Token tokenBranches7391[]; - static x64Token tokenBranches7392[]; - static x64Token tokenBranches7393[]; - static x64Token tokenBranches7394[]; - void TokenFunc7395(x64Operand& operand, int tokenPos); - void TokenFunc7405(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7405[]; - static x64Token tokenBranches7406[]; - static x64Token tokenBranches7407[]; - void TokenFunc7408(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7410[]; - static x64Token tokenBranches7411[]; - static x64Token tokenBranches7412[]; - static x64Token tokenBranches7413[]; - static x64Token tokenBranches7414[]; - static x64Token tokenBranches7415[]; - static x64Token tokenBranches7416[]; - void TokenFunc7417(x64Operand& operand, int tokenPos); - void TokenFunc7425(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7425[]; - static x64Token tokenBranches7426[]; - static x64Token tokenBranches7427[]; - void TokenFunc7428(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7429[]; - static x64Token tokenBranches7430[]; - static x64Token tokenBranches7431[]; - static x64Token tokenBranches7432[]; - static x64Token tokenBranches7433[]; - static x64Token tokenBranches7434[]; - static x64Token tokenBranches7435[]; - static x64Token tokenBranches7436[]; - static x64Token tokenBranches7437[]; - static x64Token tokenBranches7438[]; - static x64Token tokenBranches7439[]; - static x64Token tokenBranches7440[]; - void TokenFunc7441(x64Operand& operand, int tokenPos); - void TokenFunc7451(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7451[]; - static x64Token tokenBranches7452[]; - static x64Token tokenBranches7453[]; - void TokenFunc7454(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7459[]; - static x64Token tokenBranches7460[]; - static x64Token tokenBranches7461[]; - static x64Token tokenBranches7462[]; - static x64Token tokenBranches7463[]; - static x64Token tokenBranches7464[]; - static x64Token tokenBranches7465[]; - static x64Token tokenBranches7466[]; - void TokenFunc7467(x64Operand& operand, int tokenPos); - void TokenFunc7477(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7477[]; - static x64Token tokenBranches7478[]; - static x64Token tokenBranches7479[]; - void TokenFunc7480(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7482[]; - static x64Token tokenBranches7483[]; - static x64Token tokenBranches7484[]; - static x64Token tokenBranches7485[]; - static x64Token tokenBranches7486[]; - static x64Token tokenBranches7487[]; - static x64Token tokenBranches7488[]; - void TokenFunc7489(x64Operand& operand, int tokenPos); - void TokenFunc7497(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7497[]; - static x64Token tokenBranches7498[]; - static x64Token tokenBranches7499[]; - void TokenFunc7500(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7501[]; - static x64Token tokenBranches7502[]; - static x64Token tokenBranches7503[]; - static x64Token tokenBranches7504[]; - static x64Token tokenBranches7505[]; - static x64Token tokenBranches7506[]; - static x64Token tokenBranches7507[]; - static x64Token tokenBranches7508[]; - static x64Token tokenBranches7509[]; - static x64Token tokenBranches7510[]; - static x64Token tokenBranches7511[]; - static x64Token tokenBranches7512[]; - void TokenFunc7513(x64Operand& operand, int tokenPos); - void TokenFunc7523(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7523[]; - static x64Token tokenBranches7524[]; - static x64Token tokenBranches7525[]; - void TokenFunc7526(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7528[]; - static x64Token tokenBranches7529[]; - static x64Token tokenBranches7530[]; - static x64Token tokenBranches7531[]; - static x64Token tokenBranches7532[]; - static x64Token tokenBranches7533[]; - static x64Token tokenBranches7534[]; - void TokenFunc7535(x64Operand& operand, int tokenPos); - void TokenFunc7543(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7543[]; - static x64Token tokenBranches7544[]; - static x64Token tokenBranches7545[]; - void TokenFunc7546(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7547[]; - void TokenFunc7548(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7548[]; - static x64Token tokenBranches7549[]; - static x64Token tokenBranches7550[]; - static Coding tokenCoding7551_16[]; - static Coding tokenCoding7551_17[]; - static Coding tokenCoding7551_18[]; - static Coding tokenCoding7551_19[]; - void TokenFunc7551(x64Operand& operand, int tokenPos); - void TokenFunc7552(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7552[]; - static x64Token tokenBranches7553[]; - static x64Token tokenBranches7554[]; - static Coding tokenCoding7555_16[]; - static Coding tokenCoding7555_17[]; - static Coding tokenCoding7555_18[]; - static Coding tokenCoding7555_19[]; - void TokenFunc7555(x64Operand& operand, int tokenPos); - void TokenFunc7556(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7556[]; - static x64Token tokenBranches7557[]; - static x64Token tokenBranches7558[]; - static Coding tokenCoding7559_16[]; - static Coding tokenCoding7559_17[]; - static Coding tokenCoding7559_18[]; - static Coding tokenCoding7559_19[]; - void TokenFunc7559(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7560[]; - static x64Token tokenBranches7561[]; - static x64Token tokenBranches7562[]; - static Coding tokenCoding7563_16[]; - static Coding tokenCoding7563_17[]; - static Coding tokenCoding7563_18[]; - static Coding tokenCoding7563_19[]; - void TokenFunc7563(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7564[]; - static x64Token tokenBranches7565[]; - static x64Token tokenBranches7566[]; - static Coding tokenCoding7567_16[]; - static Coding tokenCoding7567_17[]; - static Coding tokenCoding7567_18[]; - static Coding tokenCoding7567_19[]; - void TokenFunc7567(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7568[]; - static x64Token tokenBranches7569[]; - static x64Token tokenBranches7570[]; - static Coding tokenCoding7571_16[]; - static Coding tokenCoding7571_17[]; - static Coding tokenCoding7571_18[]; - static Coding tokenCoding7571_19[]; - void TokenFunc7571(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7574[]; - void TokenFunc7575(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7575[]; - static x64Token tokenBranches7576[]; - static Coding tokenCoding7577_16[]; - static Coding tokenCoding7577_17[]; - static Coding tokenCoding7577_23[]; - static Coding tokenCoding7577_18[]; - static Coding tokenCoding7577_19[]; - void TokenFunc7577(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7578[]; - static x64Token tokenBranches7579[]; - static Coding tokenCoding7580_16[]; - static Coding tokenCoding7580_17[]; - static Coding tokenCoding7580_23[]; - static Coding tokenCoding7580_18[]; - static Coding tokenCoding7580_19[]; - void TokenFunc7580(x64Operand& operand, int tokenPos); - void TokenFunc7581(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7582[]; - void TokenFunc7583(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7586[]; - void TokenFunc7587(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7587[]; - static x64Token tokenBranches7588[]; - static Coding tokenCoding7589_16[]; - static Coding tokenCoding7589_17[]; - static Coding tokenCoding7589_18[]; - static Coding tokenCoding7589_19[]; - void TokenFunc7589(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7592[]; - static Coding tokenCoding7593_16[]; - static Coding tokenCoding7593_17[]; - static Coding tokenCoding7593_18[]; - static Coding tokenCoding7593_19[]; - void TokenFunc7593(x64Operand& operand, int tokenPos); - void TokenFunc7594(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7594[]; - static x64Token tokenBranches7595[]; - static Coding tokenCoding7596_16[]; - static Coding tokenCoding7596_17[]; - static Coding tokenCoding7596_18[]; - static Coding tokenCoding7596_19[]; - void TokenFunc7596(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7599[]; - static Coding tokenCoding7600_16[]; - static Coding tokenCoding7600_17[]; - static Coding tokenCoding7600_18[]; - static Coding tokenCoding7600_19[]; - void TokenFunc7600(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7606[]; - static x64Token tokenBranches7607[]; - void TokenFunc7608(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7608[]; - static x64Token tokenBranches7609[]; - void TokenFunc7610(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7611[]; - void TokenFunc7612(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7612[]; - static x64Token tokenBranches7613[]; - void TokenFunc7614(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7615[]; - void TokenFunc7616(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7616[]; - static x64Token tokenBranches7617[]; - void TokenFunc7618(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7619[]; - void TokenFunc7620(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7620[]; - static x64Token tokenBranches7621[]; - void TokenFunc7622(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7623[]; - static x64Token tokenBranches7624[]; - void TokenFunc7625(x64Operand& operand, int tokenPos); - void TokenFunc7628(x64Operand& operand, int tokenPos); - void TokenFunc7631(x64Operand& operand, int tokenPos); - void TokenFunc7634(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7635[]; - static x64Token tokenBranches7636[]; - static x64Token tokenBranches7637[]; - static x64Token tokenBranches7638[]; - static x64Token tokenBranches7639[]; - static x64Token tokenBranches7640[]; - static x64Token tokenBranches7641[]; - static x64Token tokenBranches7642[]; - void TokenFunc7643(x64Operand& operand, int tokenPos); - void TokenFunc7648(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7648[]; - static x64Token tokenBranches7649[]; - static x64Token tokenBranches7650[]; - void TokenFunc7651(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7658[]; - void TokenFunc7659(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7666[]; - void TokenFunc7667(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7672[]; - void TokenFunc7673(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7680[]; - void TokenFunc7681(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7684[]; - static x64Token tokenBranches7685[]; - static x64Token tokenBranches7686[]; - static x64Token tokenBranches7687[]; - static x64Token tokenBranches7688[]; - void TokenFunc7689(x64Operand& operand, int tokenPos); - void TokenFunc7694(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7694[]; - static x64Token tokenBranches7695[]; - static x64Token tokenBranches7696[]; - void TokenFunc7697(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7704[]; - void TokenFunc7705(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7712[]; - void TokenFunc7713(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7718[]; - void TokenFunc7719(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7726[]; - void TokenFunc7727(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7730[]; - static x64Token tokenBranches7731[]; - static x64Token tokenBranches7732[]; - static x64Token tokenBranches7733[]; - static x64Token tokenBranches7734[]; - void TokenFunc7735(x64Operand& operand, int tokenPos); - void TokenFunc7740(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7740[]; - static x64Token tokenBranches7741[]; - static x64Token tokenBranches7742[]; - void TokenFunc7743(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7750[]; - void TokenFunc7751(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7758[]; - void TokenFunc7759(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7764[]; - void TokenFunc7765(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7772[]; - void TokenFunc7773(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7777[]; - void TokenFunc7778(x64Operand& operand, int tokenPos); - void TokenFunc7779(x64Operand& operand, int tokenPos); - void TokenFunc7780(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7781[]; - static Coding tokenCoding7782_16[]; - static Coding tokenCoding7782_17[]; - static Coding tokenCoding7782_18[]; - static Coding tokenCoding7782_19[]; - void TokenFunc7782(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7783[]; - static Coding tokenCoding7784_16[]; - static Coding tokenCoding7784_17[]; - static Coding tokenCoding7784_18[]; - static Coding tokenCoding7784_19[]; - void TokenFunc7784(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7785[]; - static Coding tokenCoding7786_16[]; - static Coding tokenCoding7786_17[]; - static Coding tokenCoding7786_18[]; - static Coding tokenCoding7786_19[]; - void TokenFunc7786(x64Operand& operand, int tokenPos); - void TokenFunc7787(x64Operand& operand, int tokenPos); - void TokenFunc7788(x64Operand& operand, int tokenPos); - void TokenFunc7789(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7798[]; - static Coding tokenCoding7799_34[]; - static Coding tokenCoding7799_16[]; - static Coding tokenCoding7799_17[]; - static Coding tokenCoding7799_35[]; - static Coding tokenCoding7799_18[]; - static Coding tokenCoding7799_19[]; - void TokenFunc7799(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7800[]; - static Coding tokenCoding7801_34[]; - static Coding tokenCoding7801_16[]; - static Coding tokenCoding7801_17[]; - static Coding tokenCoding7801_35[]; - static Coding tokenCoding7801_18[]; - static Coding tokenCoding7801_19[]; - void TokenFunc7801(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7802[]; - static Coding tokenCoding7803_34[]; - static Coding tokenCoding7803_16[]; - static Coding tokenCoding7803_17[]; - static Coding tokenCoding7803_35[]; - static Coding tokenCoding7803_18[]; - static Coding tokenCoding7803_19[]; - void TokenFunc7803(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7804[]; - static Coding tokenCoding7805_34[]; - static Coding tokenCoding7805_16[]; - static Coding tokenCoding7805_17[]; - static Coding tokenCoding7805_35[]; - static Coding tokenCoding7805_18[]; - static Coding tokenCoding7805_19[]; - void TokenFunc7805(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7806[]; - void TokenFunc7807(x64Operand& operand, int tokenPos); - void TokenFunc7808(x64Operand& operand, int tokenPos); - void TokenFunc7809(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7810[]; - void TokenFunc7811(x64Operand& operand, int tokenPos); - void TokenFunc7812(x64Operand& operand, int tokenPos); - void TokenFunc7813(x64Operand& operand, int tokenPos); - void TokenFunc7814(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7815[]; - void TokenFunc7816(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7817[]; - void TokenFunc7818(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7819[]; - void TokenFunc7820(x64Operand& operand, int tokenPos); - static Coding tokenCoding7822_16[]; - static Coding tokenCoding7822_17[]; - static Coding tokenCoding7822_18[]; - static Coding tokenCoding7822_19[]; - void TokenFunc7822(x64Operand& operand, int tokenPos); - static Coding tokenCoding7824_16[]; - static Coding tokenCoding7824_17[]; - static Coding tokenCoding7824_18[]; - static Coding tokenCoding7824_19[]; - void TokenFunc7824(x64Operand& operand, int tokenPos); - static Coding tokenCoding7826_16[]; - static Coding tokenCoding7826_17[]; - static Coding tokenCoding7826_18[]; - static Coding tokenCoding7826_19[]; - void TokenFunc7826(x64Operand& operand, int tokenPos); - void TokenFunc7827(x64Operand& operand, int tokenPos); - void TokenFunc7828(x64Operand& operand, int tokenPos); - void TokenFunc7829(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7842[]; - void TokenFunc7843(x64Operand& operand, int tokenPos); - void TokenFunc7844(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7845[]; - void TokenFunc7846(x64Operand& operand, int tokenPos); - void TokenFunc7847(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7855[]; - static x64Token tokenBranches7856[]; - static x64Token tokenBranches7857[]; - static x64Token tokenBranches7858[]; - static x64Token tokenBranches7859[]; - static x64Token tokenBranches7860[]; - void TokenFunc7861(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7863[]; - void TokenFunc7864(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7864[]; - static x64Token tokenBranches7865[]; - static x64Token tokenBranches7866[]; - void TokenFunc7867(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7872[]; - void TokenFunc7873(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7878[]; - void TokenFunc7879(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7882[]; - void TokenFunc7883(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7888[]; - void TokenFunc7889(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7890[]; - static x64Token tokenBranches7891[]; - static x64Token tokenBranches7892[]; - static x64Token tokenBranches7893[]; - static x64Token tokenBranches7894[]; - void TokenFunc7895(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7897[]; - void TokenFunc7898(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7898[]; - static x64Token tokenBranches7899[]; - static x64Token tokenBranches7900[]; - void TokenFunc7901(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7906[]; - void TokenFunc7907(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7912[]; - void TokenFunc7913(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7916[]; - void TokenFunc7917(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7922[]; - void TokenFunc7923(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7924[]; - static x64Token tokenBranches7925[]; - static x64Token tokenBranches7926[]; - static x64Token tokenBranches7927[]; - static x64Token tokenBranches7928[]; - void TokenFunc7929(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7931[]; - void TokenFunc7932(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7932[]; - static x64Token tokenBranches7933[]; - static x64Token tokenBranches7934[]; - void TokenFunc7935(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7940[]; - void TokenFunc7941(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7946[]; - void TokenFunc7947(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7950[]; - void TokenFunc7951(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7956[]; - void TokenFunc7957(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7958[]; - static x64Token tokenBranches7959[]; - static x64Token tokenBranches7960[]; - static x64Token tokenBranches7961[]; - static x64Token tokenBranches7962[]; - void TokenFunc7963(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7965[]; - void TokenFunc7966(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7966[]; - static x64Token tokenBranches7967[]; - static x64Token tokenBranches7968[]; - void TokenFunc7969(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7972[]; - void TokenFunc7973(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7978[]; - void TokenFunc7979(x64Operand& operand, int tokenPos); - static x64Token tokenBranches7983[]; - void TokenFunc7984(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8023[]; - static Coding tokenCoding8024_16[]; - static Coding tokenCoding8024_17[]; - static Coding tokenCoding8024_18[]; - static Coding tokenCoding8024_19[]; - void TokenFunc8024(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8028[]; - static x64Token tokenBranches8029[]; - static x64Token tokenBranches8030[]; - static x64Token tokenBranches8031[]; - static x64Token tokenBranches8032[]; - static x64Token tokenBranches8033[]; - void TokenFunc8034(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8036[]; - void TokenFunc8037(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8037[]; - static x64Token tokenBranches8038[]; - static x64Token tokenBranches8039[]; - void TokenFunc8040(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8045[]; - void TokenFunc8046(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8051[]; - void TokenFunc8052(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8055[]; - void TokenFunc8056(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8061[]; - void TokenFunc8062(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8063[]; - static x64Token tokenBranches8064[]; - static x64Token tokenBranches8065[]; - static x64Token tokenBranches8066[]; - static x64Token tokenBranches8067[]; - void TokenFunc8068(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8070[]; - void TokenFunc8071(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8071[]; - static x64Token tokenBranches8072[]; - static x64Token tokenBranches8073[]; - void TokenFunc8074(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8079[]; - void TokenFunc8080(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8085[]; - void TokenFunc8086(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8089[]; - void TokenFunc8090(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8095[]; - void TokenFunc8096(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8097[]; - static x64Token tokenBranches8098[]; - static x64Token tokenBranches8099[]; - static x64Token tokenBranches8100[]; - static x64Token tokenBranches8101[]; - void TokenFunc8102(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8104[]; - void TokenFunc8105(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8105[]; - static x64Token tokenBranches8106[]; - static x64Token tokenBranches8107[]; - void TokenFunc8108(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8113[]; - void TokenFunc8114(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8119[]; - void TokenFunc8120(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8123[]; - void TokenFunc8124(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8129[]; - void TokenFunc8130(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8131[]; - static x64Token tokenBranches8132[]; - static x64Token tokenBranches8133[]; - static x64Token tokenBranches8134[]; - static x64Token tokenBranches8135[]; - void TokenFunc8136(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8138[]; - void TokenFunc8139(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8139[]; - static x64Token tokenBranches8140[]; - static x64Token tokenBranches8141[]; - void TokenFunc8142(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8145[]; - void TokenFunc8146(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8151[]; - void TokenFunc8152(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8156[]; - void TokenFunc8157(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8158[]; - static Coding tokenCoding8159_16[]; - static Coding tokenCoding8159_17[]; - static Coding tokenCoding8159_18[]; - static Coding tokenCoding8159_19[]; - void TokenFunc8159(x64Operand& operand, int tokenPos); - static Coding tokenCoding8160_16[]; - static Coding tokenCoding8160_17[]; - static Coding tokenCoding8160_18[]; - static Coding tokenCoding8160_19[]; - void TokenFunc8160(x64Operand& operand, int tokenPos); - static Coding tokenCoding8161_16[]; - static Coding tokenCoding8161_17[]; - static Coding tokenCoding8161_18[]; - static Coding tokenCoding8161_19[]; - void TokenFunc8161(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8167[]; - static x64Token tokenBranches8168[]; - static x64Token tokenBranches8169[]; - static x64Token tokenBranches8170[]; - void TokenFunc8171(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8172[]; - static x64Token tokenBranches8173[]; - static x64Token tokenBranches8174[]; - void TokenFunc8175(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8176[]; - static x64Token tokenBranches8177[]; - static x64Token tokenBranches8178[]; - void TokenFunc8179(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8180[]; - static x64Token tokenBranches8181[]; - static x64Token tokenBranches8182[]; - void TokenFunc8183(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8184[]; - static x64Token tokenBranches8185[]; - static x64Token tokenBranches8186[]; - static Coding tokenCoding8187_16[]; - static Coding tokenCoding8187_17[]; - static Coding tokenCoding8187_18[]; - static Coding tokenCoding8187_19[]; - void TokenFunc8187(x64Operand& operand, int tokenPos); - static Coding tokenCoding8191_16[]; - static Coding tokenCoding8191_17[]; - static Coding tokenCoding8191_23[]; - static Coding tokenCoding8191_18[]; - static Coding tokenCoding8191_19[]; - void TokenFunc8191(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8192[]; - static x64Token tokenBranches8193[]; - static x64Token tokenBranches8194[]; - static Coding tokenCoding8195_16[]; - static Coding tokenCoding8195_17[]; - static Coding tokenCoding8195_18[]; - static Coding tokenCoding8195_19[]; - void TokenFunc8195(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8196[]; - static x64Token tokenBranches8197[]; - static x64Token tokenBranches8198[]; - static Coding tokenCoding8199_16[]; - static Coding tokenCoding8199_17[]; - static Coding tokenCoding8199_18[]; - static Coding tokenCoding8199_19[]; - void TokenFunc8199(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8200[]; - static x64Token tokenBranches8201[]; - static x64Token tokenBranches8202[]; - static Coding tokenCoding8203_16[]; - static Coding tokenCoding8203_17[]; - static Coding tokenCoding8203_18[]; - static Coding tokenCoding8203_19[]; - void TokenFunc8203(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8204[]; - static x64Token tokenBranches8205[]; - static Coding tokenCoding8206_16[]; - static Coding tokenCoding8206_17[]; - static Coding tokenCoding8206_18[]; - static Coding tokenCoding8206_19[]; - void TokenFunc8206(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8207[]; - static x64Token tokenBranches8208[]; - static Coding tokenCoding8209_16[]; - static Coding tokenCoding8209_17[]; - static Coding tokenCoding8209_23[]; - static Coding tokenCoding8209_18[]; - static Coding tokenCoding8209_19[]; - void TokenFunc8209(x64Operand& operand, int tokenPos); - static Coding tokenCoding8212_16[]; - static Coding tokenCoding8212_17[]; - static Coding tokenCoding8212_23[]; - static Coding tokenCoding8212_18[]; - static Coding tokenCoding8212_19[]; - void TokenFunc8212(x64Operand& operand, int tokenPos); - static Coding tokenCoding8215_16[]; - static Coding tokenCoding8215_17[]; - static Coding tokenCoding8215_23[]; - static Coding tokenCoding8215_18[]; - static Coding tokenCoding8215_19[]; - void TokenFunc8215(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8216[]; - static x64Token tokenBranches8217[]; - static Coding tokenCoding8218_16[]; - static Coding tokenCoding8218_17[]; - static Coding tokenCoding8218_18[]; - static Coding tokenCoding8218_19[]; - void TokenFunc8218(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8219[]; - static x64Token tokenBranches8220[]; - static Coding tokenCoding8221_16[]; - static Coding tokenCoding8221_17[]; - static Coding tokenCoding8221_18[]; - static Coding tokenCoding8221_19[]; - void TokenFunc8221(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8222[]; - static x64Token tokenBranches8223[]; - static Coding tokenCoding8224_16[]; - static Coding tokenCoding8224_17[]; - static Coding tokenCoding8224_18[]; - static Coding tokenCoding8224_19[]; - void TokenFunc8224(x64Operand& operand, int tokenPos); - void TokenFunc8225(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8225[]; - static x64Token tokenBranches8226[]; - static x64Token tokenBranches8227[]; - static Coding tokenCoding8228_16[]; - static Coding tokenCoding8228_17[]; - static Coding tokenCoding8228_18[]; - static Coding tokenCoding8228_19[]; - void TokenFunc8228(x64Operand& operand, int tokenPos); - void TokenFunc8229(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8229[]; - static x64Token tokenBranches8230[]; - static x64Token tokenBranches8231[]; - static Coding tokenCoding8232_16[]; - static Coding tokenCoding8232_17[]; - static Coding tokenCoding8232_23[]; - static Coding tokenCoding8232_18[]; - static Coding tokenCoding8232_19[]; - void TokenFunc8232(x64Operand& operand, int tokenPos); - void TokenFunc8233(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8233[]; - static x64Token tokenBranches8234[]; - static x64Token tokenBranches8235[]; - static Coding tokenCoding8236_16[]; - static Coding tokenCoding8236_17[]; - static Coding tokenCoding8236_18[]; - static Coding tokenCoding8236_19[]; - void TokenFunc8236(x64Operand& operand, int tokenPos); - void TokenFunc8237(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8237[]; - static x64Token tokenBranches8238[]; - static x64Token tokenBranches8239[]; - static Coding tokenCoding8240_16[]; - static Coding tokenCoding8240_17[]; - static Coding tokenCoding8240_18[]; - static Coding tokenCoding8240_19[]; - void TokenFunc8240(x64Operand& operand, int tokenPos); - void TokenFunc8241(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8241[]; - static x64Token tokenBranches8242[]; - static x64Token tokenBranches8243[]; - static Coding tokenCoding8244_16[]; - static Coding tokenCoding8244_17[]; - static Coding tokenCoding8244_18[]; - static Coding tokenCoding8244_19[]; - void TokenFunc8244(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8247[]; - static Coding tokenCoding8248_16[]; - static Coding tokenCoding8248_17[]; - static Coding tokenCoding8248_18[]; - static Coding tokenCoding8248_19[]; - void TokenFunc8248(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8251[]; - static Coding tokenCoding8252_16[]; - static Coding tokenCoding8252_17[]; - static Coding tokenCoding8252_18[]; - static Coding tokenCoding8252_19[]; - void TokenFunc8252(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8255[]; - static Coding tokenCoding8256_16[]; - static Coding tokenCoding8256_17[]; - static Coding tokenCoding8256_18[]; - static Coding tokenCoding8256_19[]; - void TokenFunc8256(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8259[]; - static Coding tokenCoding8260_16[]; - static Coding tokenCoding8260_17[]; - static Coding tokenCoding8260_18[]; - static Coding tokenCoding8260_19[]; - void TokenFunc8260(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8261[]; - static x64Token tokenBranches8262[]; - static x64Token tokenBranches8263[]; - static x64Token tokenBranches8264[]; - static Coding tokenCoding8265_16[]; - static Coding tokenCoding8265_17[]; - static Coding tokenCoding8265_18[]; - static Coding tokenCoding8265_19[]; - void TokenFunc8265(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8266[]; - static x64Token tokenBranches8267[]; - static x64Token tokenBranches8268[]; - static x64Token tokenBranches8269[]; - static Coding tokenCoding8270_16[]; - static Coding tokenCoding8270_17[]; - static Coding tokenCoding8270_18[]; - static Coding tokenCoding8270_19[]; - void TokenFunc8270(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8271[]; - static x64Token tokenBranches8272[]; - static x64Token tokenBranches8273[]; - static x64Token tokenBranches8274[]; - static Coding tokenCoding8275_16[]; - static Coding tokenCoding8275_17[]; - static Coding tokenCoding8275_18[]; - static Coding tokenCoding8275_19[]; - void TokenFunc8275(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8276[]; - static x64Token tokenBranches8277[]; - static x64Token tokenBranches8278[]; - static x64Token tokenBranches8279[]; - static Coding tokenCoding8280_16[]; - static Coding tokenCoding8280_17[]; - static Coding tokenCoding8280_18[]; - static Coding tokenCoding8280_19[]; - void TokenFunc8280(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8282[]; - static Coding tokenCoding8283_16[]; - static Coding tokenCoding8283_17[]; - static Coding tokenCoding8283_18[]; - static Coding tokenCoding8283_19[]; - void TokenFunc8283(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8284[]; - static Coding tokenCoding8285_16[]; - static Coding tokenCoding8285_17[]; - static Coding tokenCoding8285_18[]; - static Coding tokenCoding8285_19[]; - void TokenFunc8285(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8289[]; - static x64Token tokenBranches8290[]; - static x64Token tokenBranches8291[]; - static x64Token tokenBranches8292[]; - static Coding tokenCoding8293_16[]; - static Coding tokenCoding8293_17[]; - static Coding tokenCoding8293_18[]; - static Coding tokenCoding8293_19[]; - void TokenFunc8293(x64Operand& operand, int tokenPos); - static Coding tokenCoding8297_16[]; - static Coding tokenCoding8297_17[]; - static Coding tokenCoding8297_23[]; - static Coding tokenCoding8297_18[]; - static Coding tokenCoding8297_19[]; - void TokenFunc8297(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8298[]; - static x64Token tokenBranches8299[]; - static x64Token tokenBranches8300[]; - static Coding tokenCoding8301_16[]; - static Coding tokenCoding8301_17[]; - static Coding tokenCoding8301_18[]; - static Coding tokenCoding8301_19[]; - void TokenFunc8301(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8302[]; - static x64Token tokenBranches8303[]; - static x64Token tokenBranches8304[]; - static Coding tokenCoding8305_16[]; - static Coding tokenCoding8305_17[]; - static Coding tokenCoding8305_18[]; - static Coding tokenCoding8305_19[]; - void TokenFunc8305(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8306[]; - static x64Token tokenBranches8307[]; - static x64Token tokenBranches8308[]; - static Coding tokenCoding8309_16[]; - static Coding tokenCoding8309_17[]; - static Coding tokenCoding8309_18[]; - static Coding tokenCoding8309_19[]; - void TokenFunc8309(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8310[]; - static x64Token tokenBranches8311[]; - static x64Token tokenBranches8312[]; - void TokenFunc8313(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8314[]; - static x64Token tokenBranches8315[]; - void TokenFunc8316(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8317[]; - static x64Token tokenBranches8318[]; - void TokenFunc8319(x64Operand& operand, int tokenPos); - void TokenFunc8320(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8320[]; - static x64Token tokenBranches8321[]; - void TokenFunc8322(x64Operand& operand, int tokenPos); - void TokenFunc8323(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8323[]; - static x64Token tokenBranches8324[]; - void TokenFunc8325(x64Operand& operand, int tokenPos); - void TokenFunc8326(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8326[]; - static x64Token tokenBranches8327[]; - void TokenFunc8328(x64Operand& operand, int tokenPos); - void TokenFunc8329(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8329[]; - static x64Token tokenBranches8330[]; - static x64Token tokenBranches8331[]; - static Coding tokenCoding8332_16[]; - static Coding tokenCoding8332_17[]; - static Coding tokenCoding8332_18[]; - static Coding tokenCoding8332_19[]; - void TokenFunc8332(x64Operand& operand, int tokenPos); - void TokenFunc8333(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8333[]; - static x64Token tokenBranches8334[]; - static x64Token tokenBranches8335[]; - static Coding tokenCoding8336_16[]; - static Coding tokenCoding8336_17[]; - static Coding tokenCoding8336_23[]; - static Coding tokenCoding8336_18[]; - static Coding tokenCoding8336_19[]; - void TokenFunc8336(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8339[]; - static Coding tokenCoding8340_16[]; - static Coding tokenCoding8340_17[]; - static Coding tokenCoding8340_18[]; - static Coding tokenCoding8340_19[]; - void TokenFunc8340(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8343[]; - static Coding tokenCoding8344_16[]; - static Coding tokenCoding8344_17[]; - static Coding tokenCoding8344_18[]; - static Coding tokenCoding8344_19[]; - void TokenFunc8344(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8347[]; - static Coding tokenCoding8348_16[]; - static Coding tokenCoding8348_17[]; - static Coding tokenCoding8348_18[]; - static Coding tokenCoding8348_19[]; - void TokenFunc8348(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8349[]; - static x64Token tokenBranches8350[]; - static x64Token tokenBranches8351[]; - static Coding tokenCoding8352_16[]; - static Coding tokenCoding8352_17[]; - static Coding tokenCoding8352_18[]; - static Coding tokenCoding8352_19[]; - void TokenFunc8352(x64Operand& operand, int tokenPos); - static Coding tokenCoding8356_16[]; - static Coding tokenCoding8356_17[]; - static Coding tokenCoding8356_23[]; - static Coding tokenCoding8356_18[]; - static Coding tokenCoding8356_19[]; - void TokenFunc8356(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8357[]; - static x64Token tokenBranches8358[]; - static x64Token tokenBranches8359[]; - static Coding tokenCoding8360_16[]; - static Coding tokenCoding8360_17[]; - static Coding tokenCoding8360_18[]; - static Coding tokenCoding8360_19[]; - void TokenFunc8360(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8361[]; - static x64Token tokenBranches8362[]; - static x64Token tokenBranches8363[]; - static Coding tokenCoding8364_16[]; - static Coding tokenCoding8364_17[]; - static Coding tokenCoding8364_18[]; - static Coding tokenCoding8364_19[]; - void TokenFunc8364(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8365[]; - static x64Token tokenBranches8366[]; - static x64Token tokenBranches8367[]; - static Coding tokenCoding8368_16[]; - static Coding tokenCoding8368_17[]; - static Coding tokenCoding8368_18[]; - static Coding tokenCoding8368_19[]; - void TokenFunc8368(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8369[]; - static x64Token tokenBranches8370[]; - static x64Token tokenBranches8371[]; - static x64Token tokenBranches8372[]; - static x64Token tokenBranches8373[]; - static x64Token tokenBranches8374[]; - void TokenFunc8375(x64Operand& operand, int tokenPos); - void TokenFunc8378(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8378[]; - static x64Token tokenBranches8379[]; - static x64Token tokenBranches8380[]; - void TokenFunc8381(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8386[]; - void TokenFunc8387(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8392[]; - void TokenFunc8393(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8398[]; - void TokenFunc8399(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8404[]; - void TokenFunc8405(x64Operand& operand, int tokenPos); - void TokenFunc8406(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8409[]; - static Coding tokenCoding8410_16[]; - static Coding tokenCoding8410_17[]; - static Coding tokenCoding8410_18[]; - static Coding tokenCoding8410_19[]; - void TokenFunc8410(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8411[]; - static Coding tokenCoding8412_16[]; - static Coding tokenCoding8412_17[]; - static Coding tokenCoding8412_18[]; - static Coding tokenCoding8412_19[]; - void TokenFunc8412(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8413[]; - static Coding tokenCoding8414_16[]; - static Coding tokenCoding8414_17[]; - static Coding tokenCoding8414_18[]; - static Coding tokenCoding8414_19[]; - void TokenFunc8414(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8415[]; - static Coding tokenCoding8416_16[]; - static Coding tokenCoding8416_17[]; - static Coding tokenCoding8416_18[]; - static Coding tokenCoding8416_19[]; - void TokenFunc8416(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8466[]; - void TokenFunc8467(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8467[]; - static x64Token tokenBranches8468[]; - static Coding tokenCoding8469_16[]; - static Coding tokenCoding8469_17[]; - static Coding tokenCoding8469_23[]; - static Coding tokenCoding8469_18[]; - static Coding tokenCoding8469_19[]; - void TokenFunc8469(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8470[]; - void TokenFunc8471(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8471[]; - static x64Token tokenBranches8472[]; - static Coding tokenCoding8473_16[]; - static Coding tokenCoding8473_17[]; - static Coding tokenCoding8473_23[]; - static Coding tokenCoding8473_18[]; - static Coding tokenCoding8473_19[]; - void TokenFunc8473(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8487[]; - void TokenFunc8488(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8488[]; - static x64Token tokenBranches8489[]; - static Coding tokenCoding8490_16[]; - static Coding tokenCoding8490_17[]; - static Coding tokenCoding8490_23[]; - static Coding tokenCoding8490_18[]; - static Coding tokenCoding8490_19[]; - void TokenFunc8490(x64Operand& operand, int tokenPos); - void TokenFunc8491(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8491[]; - static x64Token tokenBranches8492[]; - static Coding tokenCoding8493_16[]; - static Coding tokenCoding8493_17[]; - static Coding tokenCoding8493_23[]; - static Coding tokenCoding8493_18[]; - static Coding tokenCoding8493_19[]; - void TokenFunc8493(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8494[]; - static x64Token tokenBranches8495[]; - static Coding tokenCoding8496_16[]; - static Coding tokenCoding8496_17[]; - static Coding tokenCoding8496_23[]; - static Coding tokenCoding8496_18[]; - static Coding tokenCoding8496_19[]; - void TokenFunc8496(x64Operand& operand, int tokenPos); - static Coding tokenCoding8499_16[]; - static Coding tokenCoding8499_17[]; - static Coding tokenCoding8499_23[]; - static Coding tokenCoding8499_18[]; - static Coding tokenCoding8499_19[]; - void TokenFunc8499(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8500[]; - static x64Token tokenBranches8501[]; - static x64Token tokenBranches8502[]; - static Coding tokenCoding8503_16[]; - static Coding tokenCoding8503_17[]; - static Coding tokenCoding8503_23[]; - static Coding tokenCoding8503_18[]; - static Coding tokenCoding8503_19[]; - void TokenFunc8503(x64Operand& operand, int tokenPos); - void TokenFunc8504(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8504[]; - static x64Token tokenBranches8505[]; - static Coding tokenCoding8506_16[]; - static Coding tokenCoding8506_17[]; - static Coding tokenCoding8506_23[]; - static Coding tokenCoding8506_18[]; - static Coding tokenCoding8506_19[]; - void TokenFunc8506(x64Operand& operand, int tokenPos); - void TokenFunc8507(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8507[]; - static x64Token tokenBranches8508[]; - static Coding tokenCoding8509_16[]; - static Coding tokenCoding8509_17[]; - static Coding tokenCoding8509_23[]; - static Coding tokenCoding8509_18[]; - static Coding tokenCoding8509_19[]; - void TokenFunc8509(x64Operand& operand, int tokenPos); - static Coding tokenCoding8512_16[]; - static Coding tokenCoding8512_17[]; - static Coding tokenCoding8512_23[]; - static Coding tokenCoding8512_18[]; - static Coding tokenCoding8512_19[]; - void TokenFunc8512(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8513[]; - static x64Token tokenBranches8514[]; - static Coding tokenCoding8515_16[]; - static Coding tokenCoding8515_17[]; - static Coding tokenCoding8515_23[]; - static Coding tokenCoding8515_18[]; - static Coding tokenCoding8515_19[]; - void TokenFunc8515(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8516[]; - static x64Token tokenBranches8517[]; - static Coding tokenCoding8518_16[]; - static Coding tokenCoding8518_17[]; - static Coding tokenCoding8518_23[]; - static Coding tokenCoding8518_18[]; - static Coding tokenCoding8518_19[]; - void TokenFunc8518(x64Operand& operand, int tokenPos); - static Coding tokenCoding8521_16[]; - static Coding tokenCoding8521_17[]; - static Coding tokenCoding8521_23[]; - static Coding tokenCoding8521_18[]; - static Coding tokenCoding8521_19[]; - void TokenFunc8521(x64Operand& operand, int tokenPos); - static Coding tokenCoding8524_16[]; - static Coding tokenCoding8524_17[]; - static Coding tokenCoding8524_23[]; - static Coding tokenCoding8524_18[]; - static Coding tokenCoding8524_19[]; - void TokenFunc8524(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8529[]; - void TokenFunc8530(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8530[]; - static x64Token tokenBranches8531[]; - static Coding tokenCoding8532_16[]; - static Coding tokenCoding8532_17[]; - static Coding tokenCoding8532_23[]; - static Coding tokenCoding8532_18[]; - static Coding tokenCoding8532_19[]; - void TokenFunc8532(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8535[]; - void TokenFunc8536(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8536[]; - static x64Token tokenBranches8537[]; - static Coding tokenCoding8538_16[]; - static Coding tokenCoding8538_17[]; - static Coding tokenCoding8538_23[]; - static Coding tokenCoding8538_18[]; - static Coding tokenCoding8538_19[]; - void TokenFunc8538(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8543[]; - static x64Token tokenBranches8544[]; - static x64Token tokenBranches8545[]; - static Coding tokenCoding8546_16[]; - static Coding tokenCoding8546_17[]; - static Coding tokenCoding8546_23[]; - static Coding tokenCoding8546_18[]; - static Coding tokenCoding8546_19[]; - void TokenFunc8546(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8547[]; - static x64Token tokenBranches8548[]; - static x64Token tokenBranches8549[]; - static Coding tokenCoding8550_16[]; - static Coding tokenCoding8550_17[]; - static Coding tokenCoding8550_18[]; - void TokenFunc8550(x64Operand& operand, int tokenPos); - static Coding tokenCoding8553_16[]; - static Coding tokenCoding8553_17[]; - static Coding tokenCoding8553_18[]; - void TokenFunc8553(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8554[]; - static x64Token tokenBranches8555[]; - static x64Token tokenBranches8556[]; - static Coding tokenCoding8557_16[]; - static Coding tokenCoding8557_17[]; - static Coding tokenCoding8557_23[]; - static Coding tokenCoding8557_18[]; - static Coding tokenCoding8557_19[]; - void TokenFunc8557(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8558[]; - static x64Token tokenBranches8559[]; - static x64Token tokenBranches8560[]; - static Coding tokenCoding8561_16[]; - static Coding tokenCoding8561_17[]; - static Coding tokenCoding8561_23[]; - static Coding tokenCoding8561_18[]; - static Coding tokenCoding8561_19[]; - void TokenFunc8561(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8562[]; - static x64Token tokenBranches8563[]; - static x64Token tokenBranches8564[]; - static Coding tokenCoding8565_16[]; - static Coding tokenCoding8565_17[]; - static Coding tokenCoding8565_23[]; - static Coding tokenCoding8565_18[]; - static Coding tokenCoding8565_19[]; - void TokenFunc8565(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8566[]; - void TokenFunc8567(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8567[]; - static x64Token tokenBranches8568[]; - static Coding tokenCoding8569_16[]; - static Coding tokenCoding8569_17[]; - static Coding tokenCoding8569_23[]; - static Coding tokenCoding8569_18[]; - static Coding tokenCoding8569_19[]; - void TokenFunc8569(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8592[]; - void TokenFunc8593(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8593[]; - static x64Token tokenBranches8594[]; - static x64Token tokenBranches8595[]; - static x64Token tokenBranches8596[]; - static Coding tokenCoding8597_16[]; - static Coding tokenCoding8597_17[]; - static Coding tokenCoding8597_23[]; - static Coding tokenCoding8597_18[]; - void TokenFunc8597(x64Operand& operand, int tokenPos); - void TokenFunc8598(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8598[]; - static x64Token tokenBranches8599[]; - static x64Token tokenBranches8600[]; - static x64Token tokenBranches8601[]; - static Coding tokenCoding8602_16[]; - static Coding tokenCoding8602_17[]; - static Coding tokenCoding8602_23[]; - static Coding tokenCoding8602_18[]; - void TokenFunc8602(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8616[]; - static x64Token tokenBranches8617[]; - static x64Token tokenBranches8618[]; - void TokenFunc8619(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8619[]; - static x64Token tokenBranches8620[]; - static Coding tokenCoding8621_16[]; - static Coding tokenCoding8621_17[]; - static Coding tokenCoding8621_23[]; - static Coding tokenCoding8621_18[]; - void TokenFunc8621(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8622[]; - static x64Token tokenBranches8623[]; - static x64Token tokenBranches8624[]; - void TokenFunc8625(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8625[]; - static x64Token tokenBranches8626[]; - static Coding tokenCoding8627_16[]; - static Coding tokenCoding8627_17[]; - static Coding tokenCoding8627_23[]; - static Coding tokenCoding8627_18[]; - void TokenFunc8627(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8628[]; - static x64Token tokenBranches8629[]; - static x64Token tokenBranches8630[]; - void TokenFunc8631(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8631[]; - static x64Token tokenBranches8632[]; - static Coding tokenCoding8633_16[]; - static Coding tokenCoding8633_17[]; - static Coding tokenCoding8633_23[]; - static Coding tokenCoding8633_18[]; - void TokenFunc8633(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8634[]; - static x64Token tokenBranches8635[]; - static x64Token tokenBranches8636[]; - void TokenFunc8637(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8637[]; - static x64Token tokenBranches8638[]; - static Coding tokenCoding8639_16[]; - static Coding tokenCoding8639_17[]; - static Coding tokenCoding8639_23[]; - static Coding tokenCoding8639_18[]; - static Coding tokenCoding8639_19[]; - void TokenFunc8639(x64Operand& operand, int tokenPos); - void TokenFunc8640(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8640[]; - static x64Token tokenBranches8641[]; - static x64Token tokenBranches8642[]; - static x64Token tokenBranches8643[]; - static Coding tokenCoding8644_16[]; - static Coding tokenCoding8644_17[]; - static Coding tokenCoding8644_23[]; - static Coding tokenCoding8644_18[]; - static Coding tokenCoding8644_19[]; - void TokenFunc8644(x64Operand& operand, int tokenPos); - void TokenFunc8645(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8645[]; - static x64Token tokenBranches8646[]; - static x64Token tokenBranches8647[]; - static x64Token tokenBranches8648[]; - static Coding tokenCoding8649_16[]; - static Coding tokenCoding8649_17[]; - static Coding tokenCoding8649_23[]; - static Coding tokenCoding8649_18[]; - static Coding tokenCoding8649_19[]; - void TokenFunc8649(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8650[]; - static x64Token tokenBranches8651[]; - void TokenFunc8652(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8652[]; - static x64Token tokenBranches8653[]; - static Coding tokenCoding8654_16[]; - static Coding tokenCoding8654_17[]; - static Coding tokenCoding8654_23[]; - static Coding tokenCoding8654_18[]; - static Coding tokenCoding8654_19[]; - void TokenFunc8654(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8655[]; - void TokenFunc8656(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8656[]; - static x64Token tokenBranches8657[]; - static x64Token tokenBranches8658[]; - static x64Token tokenBranches8659[]; - static Coding tokenCoding8660_16[]; - static Coding tokenCoding8660_17[]; - static Coding tokenCoding8660_23[]; - static Coding tokenCoding8660_18[]; - void TokenFunc8660(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8661[]; - void TokenFunc8662(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8662[]; - static x64Token tokenBranches8663[]; - static x64Token tokenBranches8664[]; - static x64Token tokenBranches8665[]; - static Coding tokenCoding8666_16[]; - static Coding tokenCoding8666_17[]; - static Coding tokenCoding8666_23[]; - static Coding tokenCoding8666_18[]; - void TokenFunc8666(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8667[]; - void TokenFunc8668(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8668[]; - static x64Token tokenBranches8669[]; - static x64Token tokenBranches8670[]; - static x64Token tokenBranches8671[]; - static Coding tokenCoding8672_16[]; - static Coding tokenCoding8672_17[]; - static Coding tokenCoding8672_23[]; - static Coding tokenCoding8672_18[]; - void TokenFunc8672(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8673[]; - void TokenFunc8674(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8674[]; - static x64Token tokenBranches8675[]; - static x64Token tokenBranches8676[]; - static x64Token tokenBranches8677[]; - static Coding tokenCoding8678_16[]; - static Coding tokenCoding8678_17[]; - static Coding tokenCoding8678_23[]; - static Coding tokenCoding8678_18[]; - static Coding tokenCoding8678_19[]; - void TokenFunc8678(x64Operand& operand, int tokenPos); - void TokenFunc8679(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8679[]; - static x64Token tokenBranches8680[]; - static x64Token tokenBranches8681[]; - static x64Token tokenBranches8682[]; - static Coding tokenCoding8683_16[]; - static Coding tokenCoding8683_17[]; - static Coding tokenCoding8683_23[]; - static Coding tokenCoding8683_18[]; - static Coding tokenCoding8683_19[]; - void TokenFunc8683(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8686[]; - static x64Token tokenBranches8687[]; - static Coding tokenCoding8688_16[]; - static Coding tokenCoding8688_17[]; - static Coding tokenCoding8688_23[]; - static Coding tokenCoding8688_18[]; - static Coding tokenCoding8688_19[]; - void TokenFunc8688(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8691[]; - static x64Token tokenBranches8692[]; - static Coding tokenCoding8693_16[]; - static Coding tokenCoding8693_17[]; - static Coding tokenCoding8693_23[]; - static Coding tokenCoding8693_18[]; - static Coding tokenCoding8693_19[]; - void TokenFunc8693(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8699[]; - void TokenFunc8700(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8700[]; - static x64Token tokenBranches8701[]; - static Coding tokenCoding8702_16[]; - static Coding tokenCoding8702_17[]; - static Coding tokenCoding8702_23[]; - static Coding tokenCoding8702_18[]; - void TokenFunc8702(x64Operand& operand, int tokenPos); - void TokenFunc8703(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8703[]; - static x64Token tokenBranches8704[]; - static Coding tokenCoding8705_16[]; - static Coding tokenCoding8705_17[]; - static Coding tokenCoding8705_23[]; - static Coding tokenCoding8705_18[]; - void TokenFunc8705(x64Operand& operand, int tokenPos); - static Coding tokenCoding8708_16[]; - static Coding tokenCoding8708_17[]; - static Coding tokenCoding8708_23[]; - static Coding tokenCoding8708_18[]; - void TokenFunc8708(x64Operand& operand, int tokenPos); - static Coding tokenCoding8711_16[]; - static Coding tokenCoding8711_17[]; - static Coding tokenCoding8711_23[]; - static Coding tokenCoding8711_18[]; - void TokenFunc8711(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8720[]; - void TokenFunc8721(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8721[]; - static x64Token tokenBranches8722[]; - static x64Token tokenBranches8723[]; - static x64Token tokenBranches8724[]; - static Coding tokenCoding8725_16[]; - static Coding tokenCoding8725_17[]; - static Coding tokenCoding8725_18[]; - void TokenFunc8725(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8727[]; - static x64Token tokenBranches8728[]; - static x64Token tokenBranches8729[]; - static Coding tokenCoding8730_16[]; - static Coding tokenCoding8730_17[]; - static Coding tokenCoding8730_18[]; - void TokenFunc8730(x64Operand& operand, int tokenPos); - static x64Token tokenBranches8736[]; - static x64Token tokenBranches8737[]; - static x64Token tokenBranches8738[]; - static Coding tokenCoding8739_16[]; - static Coding tokenCoding8739_17[]; - static Coding tokenCoding8739_18[]; - void TokenFunc8739(x64Operand& operand, int tokenPos); + static x64Token tokenBranches1[]; + static x64Token tokenBranches2[]; + void TokenFunc3(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3[]; + void TokenFunc4(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6[]; + static x64Token tokenBranches7[]; + void TokenFunc8(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8[]; + void TokenFunc9(x64Operand &operand, int tokenPos); + static x64Token tokenBranches11[]; + static x64Token tokenBranches12[]; + void TokenFunc13(x64Operand &operand, int tokenPos); + static x64Token tokenBranches13[]; + void TokenFunc14(x64Operand &operand, int tokenPos); + void TokenFunc16(x64Operand &operand, int tokenPos); + static x64Token tokenBranches16[]; + static x64Token tokenBranches17[]; + void TokenFunc18(x64Operand &operand, int tokenPos); + static x64Token tokenBranches18[]; + void TokenFunc19(x64Operand &operand, int tokenPos); + static x64Token tokenBranches21[]; + static x64Token tokenBranches22[]; + void TokenFunc23(x64Operand &operand, int tokenPos); + static x64Token tokenBranches23[]; + void TokenFunc24(x64Operand &operand, int tokenPos); + static x64Token tokenBranches26[]; + static x64Token tokenBranches27[]; + void TokenFunc28(x64Operand &operand, int tokenPos); + static x64Token tokenBranches28[]; + void TokenFunc29(x64Operand &operand, int tokenPos); + static x64Token tokenBranches33[]; + static x64Token tokenBranches34[]; + void TokenFunc35(x64Operand &operand, int tokenPos); + static x64Token tokenBranches35[]; + void TokenFunc36(x64Operand &operand, int tokenPos); + static x64Token tokenBranches40[]; + static x64Token tokenBranches41[]; + void TokenFunc42(x64Operand &operand, int tokenPos); + static x64Token tokenBranches42[]; + void TokenFunc43(x64Operand &operand, int tokenPos); + static x64Token tokenBranches47[]; + static x64Token tokenBranches48[]; + void TokenFunc49(x64Operand &operand, int tokenPos); + static x64Token tokenBranches49[]; + void TokenFunc50(x64Operand &operand, int tokenPos); + static x64Token tokenBranches54[]; + static x64Token tokenBranches55[]; + void TokenFunc56(x64Operand &operand, int tokenPos); + static x64Token tokenBranches56[]; + void TokenFunc57(x64Operand &operand, int tokenPos); + static x64Token tokenBranches61[]; + static x64Token tokenBranches62[]; + void TokenFunc63(x64Operand &operand, int tokenPos); + static x64Token tokenBranches63[]; + void TokenFunc64(x64Operand &operand, int tokenPos); + static x64Token tokenBranches68[]; + static x64Token tokenBranches69[]; + void TokenFunc70(x64Operand &operand, int tokenPos); + static x64Token tokenBranches70[]; + void TokenFunc71(x64Operand &operand, int tokenPos); + void TokenFunc73(x64Operand &operand, int tokenPos); + static x64Token tokenBranches73[]; + void TokenFunc74(x64Operand &operand, int tokenPos); + void TokenFunc78(x64Operand &operand, int tokenPos); + static x64Token tokenBranches78[]; + void TokenFunc79(x64Operand &operand, int tokenPos); + void TokenFunc83(x64Operand &operand, int tokenPos); + static x64Token tokenBranches83[]; + void TokenFunc84(x64Operand &operand, int tokenPos); + void TokenFunc88(x64Operand &operand, int tokenPos); + static x64Token tokenBranches88[]; + void TokenFunc89(x64Operand &operand, int tokenPos); + void TokenFunc92(x64Operand &operand, int tokenPos); + void TokenFunc97(x64Operand &operand, int tokenPos); + void TokenFunc102(x64Operand &operand, int tokenPos); + void TokenFunc107(x64Operand &operand, int tokenPos); + void TokenFunc110(x64Operand &operand, int tokenPos); + void TokenFunc115(x64Operand &operand, int tokenPos); + void TokenFunc120(x64Operand &operand, int tokenPos); + void TokenFunc125(x64Operand &operand, int tokenPos); + void TokenFunc129(x64Operand &operand, int tokenPos); + static x64Token tokenBranches129[]; + void TokenFunc130(x64Operand &operand, int tokenPos); + void TokenFunc136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches136[]; + void TokenFunc137(x64Operand &operand, int tokenPos); + void TokenFunc143(x64Operand &operand, int tokenPos); + static x64Token tokenBranches143[]; + void TokenFunc144(x64Operand &operand, int tokenPos); + void TokenFunc150(x64Operand &operand, int tokenPos); + static x64Token tokenBranches150[]; + void TokenFunc151(x64Operand &operand, int tokenPos); + void TokenFunc155(x64Operand &operand, int tokenPos); + static x64Token tokenBranches155[]; + void TokenFunc156(x64Operand &operand, int tokenPos); + void TokenFunc162(x64Operand &operand, int tokenPos); + static x64Token tokenBranches162[]; + void TokenFunc163(x64Operand &operand, int tokenPos); + void TokenFunc169(x64Operand &operand, int tokenPos); + static x64Token tokenBranches169[]; + void TokenFunc170(x64Operand &operand, int tokenPos); + void TokenFunc176(x64Operand &operand, int tokenPos); + static x64Token tokenBranches176[]; + void TokenFunc177(x64Operand &operand, int tokenPos); + static x64Token tokenBranches182[]; + void TokenFunc183(x64Operand &operand, int tokenPos); + static x64Token tokenBranches183[]; + void TokenFunc184(x64Operand &operand, int tokenPos); + static x64Token tokenBranches189[]; + void TokenFunc190(x64Operand &operand, int tokenPos); + static x64Token tokenBranches190[]; + void TokenFunc191(x64Operand &operand, int tokenPos); + static x64Token tokenBranches198[]; + void TokenFunc199(x64Operand &operand, int tokenPos); + static x64Token tokenBranches199[]; + void TokenFunc200(x64Operand &operand, int tokenPos); + static x64Token tokenBranches207[]; + void TokenFunc208(x64Operand &operand, int tokenPos); + static x64Token tokenBranches208[]; + void TokenFunc209(x64Operand &operand, int tokenPos); + static x64Token tokenBranches216[]; + void TokenFunc217(x64Operand &operand, int tokenPos); + static x64Token tokenBranches217[]; + void TokenFunc218(x64Operand &operand, int tokenPos); + static x64Token tokenBranches225[]; + void TokenFunc226(x64Operand &operand, int tokenPos); + static x64Token tokenBranches226[]; + void TokenFunc227(x64Operand &operand, int tokenPos); + static x64Token tokenBranches234[]; + void TokenFunc235(x64Operand &operand, int tokenPos); + static x64Token tokenBranches235[]; + void TokenFunc236(x64Operand &operand, int tokenPos); + static x64Token tokenBranches243[]; + void TokenFunc244(x64Operand &operand, int tokenPos); + static x64Token tokenBranches244[]; + void TokenFunc245(x64Operand &operand, int tokenPos); + static x64Token tokenBranches248[]; + void TokenFunc249(x64Operand &operand, int tokenPos); + static x64Token tokenBranches249[]; + void TokenFunc250(x64Operand &operand, int tokenPos); + static x64Token tokenBranches255[]; + void TokenFunc256(x64Operand &operand, int tokenPos); + static x64Token tokenBranches256[]; + void TokenFunc257(x64Operand &operand, int tokenPos); + static x64Token tokenBranches262[]; + void TokenFunc263(x64Operand &operand, int tokenPos); + static x64Token tokenBranches263[]; + void TokenFunc264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches269[]; + void TokenFunc270(x64Operand &operand, int tokenPos); + static x64Token tokenBranches270[]; + void TokenFunc271(x64Operand &operand, int tokenPos); + void TokenFunc275(x64Operand &operand, int tokenPos); + static x64Token tokenBranches275[]; + void TokenFunc276(x64Operand &operand, int tokenPos); + void TokenFunc282(x64Operand &operand, int tokenPos); + static x64Token tokenBranches282[]; + void TokenFunc283(x64Operand &operand, int tokenPos); + void TokenFunc289(x64Operand &operand, int tokenPos); + static x64Token tokenBranches289[]; + void TokenFunc290(x64Operand &operand, int tokenPos); + void TokenFunc296(x64Operand &operand, int tokenPos); + static x64Token tokenBranches296[]; + void TokenFunc297(x64Operand &operand, int tokenPos); + void TokenFunc301(x64Operand &operand, int tokenPos); + static x64Token tokenBranches301[]; + void TokenFunc302(x64Operand &operand, int tokenPos); + void TokenFunc308(x64Operand &operand, int tokenPos); + static x64Token tokenBranches308[]; + void TokenFunc309(x64Operand &operand, int tokenPos); + void TokenFunc315(x64Operand &operand, int tokenPos); + static x64Token tokenBranches315[]; + void TokenFunc316(x64Operand &operand, int tokenPos); + void TokenFunc322(x64Operand &operand, int tokenPos); + static x64Token tokenBranches322[]; + void TokenFunc323(x64Operand &operand, int tokenPos); + void TokenFunc329(x64Operand &operand, int tokenPos); + static x64Token tokenBranches329[]; + void TokenFunc330(x64Operand &operand, int tokenPos); + void TokenFunc336(x64Operand &operand, int tokenPos); + static x64Token tokenBranches336[]; + void TokenFunc337(x64Operand &operand, int tokenPos); + void TokenFunc345(x64Operand &operand, int tokenPos); + static x64Token tokenBranches345[]; + void TokenFunc346(x64Operand &operand, int tokenPos); + void TokenFunc354(x64Operand &operand, int tokenPos); + static x64Token tokenBranches354[]; + void TokenFunc355(x64Operand &operand, int tokenPos); + void TokenFunc363(x64Operand &operand, int tokenPos); + static x64Token tokenBranches363[]; + void TokenFunc364(x64Operand &operand, int tokenPos); + void TokenFunc372(x64Operand &operand, int tokenPos); + static x64Token tokenBranches372[]; + void TokenFunc373(x64Operand &operand, int tokenPos); + void TokenFunc381(x64Operand &operand, int tokenPos); + static x64Token tokenBranches381[]; + void TokenFunc382(x64Operand &operand, int tokenPos); + void TokenFunc390(x64Operand &operand, int tokenPos); + static x64Token tokenBranches390[]; + void TokenFunc391(x64Operand &operand, int tokenPos); + void TokenFunc395(x64Operand &operand, int tokenPos); + static x64Token tokenBranches395[]; + void TokenFunc396(x64Operand &operand, int tokenPos); + void TokenFunc402(x64Operand &operand, int tokenPos); + static x64Token tokenBranches402[]; + void TokenFunc403(x64Operand &operand, int tokenPos); + void TokenFunc409(x64Operand &operand, int tokenPos); + static x64Token tokenBranches409[]; + void TokenFunc410(x64Operand &operand, int tokenPos); + void TokenFunc416(x64Operand &operand, int tokenPos); + static x64Token tokenBranches416[]; + void TokenFunc417(x64Operand &operand, int tokenPos); + void TokenFunc421(x64Operand &operand, int tokenPos); + static x64Token tokenBranches421[]; + void TokenFunc422(x64Operand &operand, int tokenPos); + void TokenFunc428(x64Operand &operand, int tokenPos); + static x64Token tokenBranches428[]; + void TokenFunc429(x64Operand &operand, int tokenPos); + void TokenFunc435(x64Operand &operand, int tokenPos); + static x64Token tokenBranches435[]; + void TokenFunc436(x64Operand &operand, int tokenPos); + void TokenFunc442(x64Operand &operand, int tokenPos); + static x64Token tokenBranches442[]; + void TokenFunc443(x64Operand &operand, int tokenPos); + void TokenFunc447(x64Operand &operand, int tokenPos); + static x64Token tokenBranches447[]; + void TokenFunc448(x64Operand &operand, int tokenPos); + void TokenFunc454(x64Operand &operand, int tokenPos); + static x64Token tokenBranches454[]; + void TokenFunc455(x64Operand &operand, int tokenPos); + void TokenFunc461(x64Operand &operand, int tokenPos); + static x64Token tokenBranches461[]; + void TokenFunc462(x64Operand &operand, int tokenPos); + void TokenFunc468(x64Operand &operand, int tokenPos); + static x64Token tokenBranches468[]; + void TokenFunc469(x64Operand &operand, int tokenPos); + static x64Token tokenBranches471[]; + void TokenFunc472(x64Operand &operand, int tokenPos); + static x64Token tokenBranches474[]; + void TokenFunc475(x64Operand &operand, int tokenPos); + static x64Token tokenBranches477[]; + void TokenFunc478(x64Operand &operand, int tokenPos); + void TokenFunc480(x64Operand &operand, int tokenPos); + static x64Token tokenBranches480[]; + void TokenFunc481(x64Operand &operand, int tokenPos); + static x64Token tokenBranches484[]; + static x64Token tokenBranches485[]; + void TokenFunc486(x64Operand &operand, int tokenPos); + static x64Token tokenBranches490[]; + void TokenFunc491(x64Operand &operand, int tokenPos); + static x64Token tokenBranches495[]; + void TokenFunc496(x64Operand &operand, int tokenPos); + static x64Token tokenBranches500[]; + void TokenFunc501(x64Operand &operand, int tokenPos); + static x64Token tokenBranches505[]; + void TokenFunc506(x64Operand &operand, int tokenPos); + static x64Token tokenBranches510[]; + void TokenFunc511(x64Operand &operand, int tokenPos); + static x64Token tokenBranches515[]; + void TokenFunc516(x64Operand &operand, int tokenPos); + static x64Token tokenBranches520[]; + void TokenFunc521(x64Operand &operand, int tokenPos); + void TokenFunc525(x64Operand &operand, int tokenPos); + static x64Token tokenBranches525[]; + void TokenFunc526(x64Operand &operand, int tokenPos); + void TokenFunc530(x64Operand &operand, int tokenPos); + static x64Token tokenBranches530[]; + void TokenFunc531(x64Operand &operand, int tokenPos); + static x64Token tokenBranches536[]; + static x64Token tokenBranches537[]; + void TokenFunc538(x64Operand &operand, int tokenPos); + static x64Token tokenBranches543[]; + static x64Token tokenBranches544[]; + void TokenFunc545(x64Operand &operand, int tokenPos); + void TokenFunc549(x64Operand &operand, int tokenPos); + static x64Token tokenBranches549[]; + void TokenFunc550(x64Operand &operand, int tokenPos); + static x64Token tokenBranches555[]; + static x64Token tokenBranches556[]; + void TokenFunc557(x64Operand &operand, int tokenPos); + void TokenFunc559(x64Operand &operand, int tokenPos); + static x64Token tokenBranches559[]; + void TokenFunc560(x64Operand &operand, int tokenPos); + void TokenFunc564(x64Operand &operand, int tokenPos); + static x64Token tokenBranches564[]; + void TokenFunc565(x64Operand &operand, int tokenPos); + void TokenFunc569(x64Operand &operand, int tokenPos); + static x64Token tokenBranches569[]; + void TokenFunc570(x64Operand &operand, int tokenPos); + void TokenFunc574(x64Operand &operand, int tokenPos); + static x64Token tokenBranches574[]; + void TokenFunc575(x64Operand &operand, int tokenPos); + static x64Token tokenBranches578[]; + void TokenFunc579(x64Operand &operand, int tokenPos); + static x64Token tokenBranches579[]; + void TokenFunc580(x64Operand &operand, int tokenPos); + static x64Token tokenBranches583[]; + void TokenFunc584(x64Operand &operand, int tokenPos); + static x64Token tokenBranches584[]; + void TokenFunc585(x64Operand &operand, int tokenPos); + static x64Token tokenBranches590[]; + void TokenFunc591(x64Operand &operand, int tokenPos); + static x64Token tokenBranches591[]; + void TokenFunc592(x64Operand &operand, int tokenPos); + static x64Token tokenBranches597[]; + void TokenFunc598(x64Operand &operand, int tokenPos); + static x64Token tokenBranches598[]; + void TokenFunc599(x64Operand &operand, int tokenPos); + static x64Token tokenBranches604[]; + void TokenFunc605(x64Operand &operand, int tokenPos); + static x64Token tokenBranches605[]; + void TokenFunc606(x64Operand &operand, int tokenPos); + static x64Token tokenBranches611[]; + void TokenFunc612(x64Operand &operand, int tokenPos); + static x64Token tokenBranches612[]; + void TokenFunc613(x64Operand &operand, int tokenPos); + static x64Token tokenBranches616[]; + void TokenFunc617(x64Operand &operand, int tokenPos); + static x64Token tokenBranches617[]; + void TokenFunc618(x64Operand &operand, int tokenPos); + void TokenFunc622(x64Operand &operand, int tokenPos); + static x64Token tokenBranches622[]; + void TokenFunc623(x64Operand &operand, int tokenPos); + static x64Token tokenBranches628[]; + void TokenFunc629(x64Operand &operand, int tokenPos); + static x64Token tokenBranches629[]; + void TokenFunc630(x64Operand &operand, int tokenPos); + static x64Token tokenBranches635[]; + void TokenFunc636(x64Operand &operand, int tokenPos); + static x64Token tokenBranches636[]; + void TokenFunc637(x64Operand &operand, int tokenPos); + void TokenFunc643(x64Operand &operand, int tokenPos); + static x64Token tokenBranches643[]; + void TokenFunc644(x64Operand &operand, int tokenPos); + static x64Token tokenBranches651[]; + void TokenFunc652(x64Operand &operand, int tokenPos); + static x64Token tokenBranches652[]; + void TokenFunc653(x64Operand &operand, int tokenPos); + void TokenFunc659(x64Operand &operand, int tokenPos); + static x64Token tokenBranches659[]; + void TokenFunc660(x64Operand &operand, int tokenPos); + static x64Token tokenBranches667[]; + void TokenFunc668(x64Operand &operand, int tokenPos); + static x64Token tokenBranches668[]; + void TokenFunc669(x64Operand &operand, int tokenPos); + void TokenFunc675(x64Operand &operand, int tokenPos); + static x64Token tokenBranches675[]; + void TokenFunc676(x64Operand &operand, int tokenPos); + static x64Token tokenBranches683[]; + void TokenFunc684(x64Operand &operand, int tokenPos); + static x64Token tokenBranches684[]; + void TokenFunc685(x64Operand &operand, int tokenPos); + void TokenFunc689(x64Operand &operand, int tokenPos); + static x64Token tokenBranches689[]; + void TokenFunc690(x64Operand &operand, int tokenPos); + void TokenFunc694(x64Operand &operand, int tokenPos); + static x64Token tokenBranches694[]; + void TokenFunc695(x64Operand &operand, int tokenPos); + void TokenFunc701(x64Operand &operand, int tokenPos); + static x64Token tokenBranches701[]; + void TokenFunc702(x64Operand &operand, int tokenPos); + void TokenFunc708(x64Operand &operand, int tokenPos); + static x64Token tokenBranches708[]; + void TokenFunc709(x64Operand &operand, int tokenPos); + void TokenFunc715(x64Operand &operand, int tokenPos); + static x64Token tokenBranches715[]; + void TokenFunc716(x64Operand &operand, int tokenPos); + void TokenFunc722(x64Operand &operand, int tokenPos); + static x64Token tokenBranches722[]; + void TokenFunc723(x64Operand &operand, int tokenPos); + static x64Token tokenBranches728[]; + void TokenFunc729(x64Operand &operand, int tokenPos); + static x64Token tokenBranches729[]; + void TokenFunc730(x64Operand &operand, int tokenPos); + static x64Token tokenBranches735[]; + void TokenFunc736(x64Operand &operand, int tokenPos); + static x64Token tokenBranches736[]; + void TokenFunc737(x64Operand &operand, int tokenPos); + void TokenFunc741(x64Operand &operand, int tokenPos); + static x64Token tokenBranches741[]; + void TokenFunc742(x64Operand &operand, int tokenPos); + void TokenFunc746(x64Operand &operand, int tokenPos); + static x64Token tokenBranches746[]; + void TokenFunc747(x64Operand &operand, int tokenPos); + void TokenFunc753(x64Operand &operand, int tokenPos); + static x64Token tokenBranches753[]; + void TokenFunc754(x64Operand &operand, int tokenPos); + void TokenFunc760(x64Operand &operand, int tokenPos); + static x64Token tokenBranches760[]; + void TokenFunc761(x64Operand &operand, int tokenPos); + void TokenFunc767(x64Operand &operand, int tokenPos); + static x64Token tokenBranches767[]; + void TokenFunc768(x64Operand &operand, int tokenPos); + void TokenFunc776(x64Operand &operand, int tokenPos); + static x64Token tokenBranches776[]; + void TokenFunc777(x64Operand &operand, int tokenPos); + void TokenFunc783(x64Operand &operand, int tokenPos); + static x64Token tokenBranches783[]; + void TokenFunc784(x64Operand &operand, int tokenPos); + void TokenFunc792(x64Operand &operand, int tokenPos); + static x64Token tokenBranches792[]; + void TokenFunc793(x64Operand &operand, int tokenPos); + void TokenFunc799(x64Operand &operand, int tokenPos); + static x64Token tokenBranches799[]; + void TokenFunc800(x64Operand &operand, int tokenPos); + void TokenFunc808(x64Operand &operand, int tokenPos); + static x64Token tokenBranches808[]; + void TokenFunc809(x64Operand &operand, int tokenPos); + void TokenFunc813(x64Operand &operand, int tokenPos); + static x64Token tokenBranches813[]; + void TokenFunc814(x64Operand &operand, int tokenPos); + void TokenFunc818(x64Operand &operand, int tokenPos); + static x64Token tokenBranches818[]; + void TokenFunc819(x64Operand &operand, int tokenPos); + void TokenFunc825(x64Operand &operand, int tokenPos); + static x64Token tokenBranches825[]; + void TokenFunc826(x64Operand &operand, int tokenPos); + void TokenFunc832(x64Operand &operand, int tokenPos); + static x64Token tokenBranches832[]; + void TokenFunc833(x64Operand &operand, int tokenPos); + void TokenFunc839(x64Operand &operand, int tokenPos); + static x64Token tokenBranches839[]; + void TokenFunc840(x64Operand &operand, int tokenPos); + void TokenFunc846(x64Operand &operand, int tokenPos); + static x64Token tokenBranches846[]; + void TokenFunc847(x64Operand &operand, int tokenPos); + void TokenFunc853(x64Operand &operand, int tokenPos); + static x64Token tokenBranches853[]; + void TokenFunc854(x64Operand &operand, int tokenPos); + void TokenFunc860(x64Operand &operand, int tokenPos); + static x64Token tokenBranches860[]; + void TokenFunc861(x64Operand &operand, int tokenPos); + void TokenFunc865(x64Operand &operand, int tokenPos); + static x64Token tokenBranches865[]; + void TokenFunc866(x64Operand &operand, int tokenPos); + void TokenFunc870(x64Operand &operand, int tokenPos); + static x64Token tokenBranches870[]; + void TokenFunc871(x64Operand &operand, int tokenPos); + void TokenFunc877(x64Operand &operand, int tokenPos); + static x64Token tokenBranches877[]; + void TokenFunc878(x64Operand &operand, int tokenPos); + void TokenFunc884(x64Operand &operand, int tokenPos); + static x64Token tokenBranches884[]; + void TokenFunc885(x64Operand &operand, int tokenPos); + void TokenFunc891(x64Operand &operand, int tokenPos); + static x64Token tokenBranches891[]; + void TokenFunc892(x64Operand &operand, int tokenPos); + void TokenFunc900(x64Operand &operand, int tokenPos); + static x64Token tokenBranches900[]; + void TokenFunc901(x64Operand &operand, int tokenPos); + void TokenFunc907(x64Operand &operand, int tokenPos); + static x64Token tokenBranches907[]; + void TokenFunc908(x64Operand &operand, int tokenPos); + void TokenFunc916(x64Operand &operand, int tokenPos); + static x64Token tokenBranches916[]; + void TokenFunc917(x64Operand &operand, int tokenPos); + void TokenFunc925(x64Operand &operand, int tokenPos); + static x64Token tokenBranches925[]; + void TokenFunc926(x64Operand &operand, int tokenPos); + void TokenFunc932(x64Operand &operand, int tokenPos); + static x64Token tokenBranches932[]; + void TokenFunc933(x64Operand &operand, int tokenPos); + static x64Token tokenBranches936[]; + void TokenFunc937(x64Operand &operand, int tokenPos); + static x64Token tokenBranches937[]; + void TokenFunc938(x64Operand &operand, int tokenPos); + static x64Token tokenBranches943[]; + void TokenFunc944(x64Operand &operand, int tokenPos); + static x64Token tokenBranches944[]; + void TokenFunc945(x64Operand &operand, int tokenPos); + void TokenFunc951(x64Operand &operand, int tokenPos); + static x64Token tokenBranches951[]; + void TokenFunc952(x64Operand &operand, int tokenPos); + void TokenFunc958(x64Operand &operand, int tokenPos); + static x64Token tokenBranches958[]; + void TokenFunc959(x64Operand &operand, int tokenPos); + static x64Token tokenBranches964[]; + void TokenFunc965(x64Operand &operand, int tokenPos); + static x64Token tokenBranches965[]; + void TokenFunc966(x64Operand &operand, int tokenPos); + static x64Token tokenBranches973[]; + void TokenFunc974(x64Operand &operand, int tokenPos); + static x64Token tokenBranches974[]; + void TokenFunc975(x64Operand &operand, int tokenPos); + void TokenFunc983(x64Operand &operand, int tokenPos); + static x64Token tokenBranches983[]; + void TokenFunc984(x64Operand &operand, int tokenPos); + void TokenFunc992(x64Operand &operand, int tokenPos); + static x64Token tokenBranches992[]; + void TokenFunc993(x64Operand &operand, int tokenPos); + static x64Token tokenBranches998[]; + void TokenFunc999(x64Operand &operand, int tokenPos); + static x64Token tokenBranches999[]; + void TokenFunc1000(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1007[]; + void TokenFunc1008(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1008[]; + void TokenFunc1009(x64Operand &operand, int tokenPos); + void TokenFunc1017(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1017[]; + void TokenFunc1018(x64Operand &operand, int tokenPos); + void TokenFunc1026(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1026[]; + void TokenFunc1027(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1032[]; + void TokenFunc1033(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1033[]; + void TokenFunc1034(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1041[]; + void TokenFunc1042(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1042[]; + void TokenFunc1043(x64Operand &operand, int tokenPos); + void TokenFunc1051(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1051[]; + void TokenFunc1052(x64Operand &operand, int tokenPos); + void TokenFunc1060(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1060[]; + void TokenFunc1061(x64Operand &operand, int tokenPos); + void TokenFunc1065(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1065[]; + void TokenFunc1066(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1071[]; + void TokenFunc1072(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1072[]; + void TokenFunc1073(x64Operand &operand, int tokenPos); + void TokenFunc1079(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1079[]; + void TokenFunc1080(x64Operand &operand, int tokenPos); + void TokenFunc1086(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1086[]; + void TokenFunc1087(x64Operand &operand, int tokenPos); + void TokenFunc1093(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1093[]; + void TokenFunc1094(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1101[]; + void TokenFunc1102(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1102[]; + void TokenFunc1103(x64Operand &operand, int tokenPos); + void TokenFunc1111(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1111[]; + void TokenFunc1112(x64Operand &operand, int tokenPos); + void TokenFunc1120(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1120[]; + void TokenFunc1121(x64Operand &operand, int tokenPos); + void TokenFunc1127(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1127[]; + void TokenFunc1128(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1135[]; + void TokenFunc1136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1136[]; + void TokenFunc1137(x64Operand &operand, int tokenPos); + void TokenFunc1145(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1145[]; + void TokenFunc1146(x64Operand &operand, int tokenPos); + void TokenFunc1154(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1154[]; + void TokenFunc1155(x64Operand &operand, int tokenPos); + void TokenFunc1161(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1161[]; + void TokenFunc1162(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1169[]; + void TokenFunc1170(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1170[]; + void TokenFunc1171(x64Operand &operand, int tokenPos); + void TokenFunc1179(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1179[]; + void TokenFunc1180(x64Operand &operand, int tokenPos); + void TokenFunc1188(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1188[]; + void TokenFunc1189(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1192[]; + void TokenFunc1193(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1193[]; + void TokenFunc1194(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1199[]; + void TokenFunc1200(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1200[]; + void TokenFunc1201(x64Operand &operand, int tokenPos); + void TokenFunc1207(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1207[]; + void TokenFunc1208(x64Operand &operand, int tokenPos); + void TokenFunc1214(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1214[]; + void TokenFunc1215(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1219[]; + static x64Token tokenBranches1220[]; + void TokenFunc1221(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1221[]; + void TokenFunc1222(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1229[]; + void TokenFunc1230(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1230[]; + void TokenFunc1231(x64Operand &operand, int tokenPos); + void TokenFunc1239(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1239[]; + void TokenFunc1240(x64Operand &operand, int tokenPos); + void TokenFunc1248(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1248[]; + void TokenFunc1249(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1253[]; + static x64Token tokenBranches1254[]; + void TokenFunc1255(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1255[]; + void TokenFunc1256(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1263[]; + void TokenFunc1264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1264[]; + void TokenFunc1265(x64Operand &operand, int tokenPos); + void TokenFunc1273(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1273[]; + void TokenFunc1274(x64Operand &operand, int tokenPos); + void TokenFunc1282(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1282[]; + void TokenFunc1283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1288[]; + void TokenFunc1289(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1289[]; + void TokenFunc1290(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1297[]; + void TokenFunc1298(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1298[]; + void TokenFunc1299(x64Operand &operand, int tokenPos); + void TokenFunc1307(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1307[]; + void TokenFunc1308(x64Operand &operand, int tokenPos); + void TokenFunc1316(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1316[]; + void TokenFunc1317(x64Operand &operand, int tokenPos); + void TokenFunc1321(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1321[]; + void TokenFunc1322(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1327[]; + void TokenFunc1328(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1328[]; + void TokenFunc1329(x64Operand &operand, int tokenPos); + void TokenFunc1335(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1335[]; + void TokenFunc1336(x64Operand &operand, int tokenPos); + void TokenFunc1342(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1342[]; + void TokenFunc1343(x64Operand &operand, int tokenPos); + void TokenFunc1349(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1349[]; + void TokenFunc1350(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1357[]; + void TokenFunc1358(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1358[]; + void TokenFunc1359(x64Operand &operand, int tokenPos); + void TokenFunc1367(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1367[]; + void TokenFunc1368(x64Operand &operand, int tokenPos); + void TokenFunc1376(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1376[]; + void TokenFunc1377(x64Operand &operand, int tokenPos); + void TokenFunc1383(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1383[]; + void TokenFunc1384(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1391[]; + void TokenFunc1392(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1392[]; + void TokenFunc1393(x64Operand &operand, int tokenPos); + void TokenFunc1401(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1401[]; + void TokenFunc1402(x64Operand &operand, int tokenPos); + void TokenFunc1410(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1410[]; + void TokenFunc1411(x64Operand &operand, int tokenPos); + void TokenFunc1417(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1417[]; + void TokenFunc1418(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1425[]; + void TokenFunc1426(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1426[]; + void TokenFunc1427(x64Operand &operand, int tokenPos); + void TokenFunc1435(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1435[]; + void TokenFunc1436(x64Operand &operand, int tokenPos); + void TokenFunc1444(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1444[]; + void TokenFunc1445(x64Operand &operand, int tokenPos); + void TokenFunc1449(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1449[]; + void TokenFunc1450(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1455[]; + void TokenFunc1456(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1456[]; + void TokenFunc1457(x64Operand &operand, int tokenPos); + void TokenFunc1463(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1463[]; + void TokenFunc1464(x64Operand &operand, int tokenPos); + void TokenFunc1470(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1470[]; + void TokenFunc1471(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1478[]; + void TokenFunc1479(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1479[]; + void TokenFunc1480(x64Operand &operand, int tokenPos); + void TokenFunc1488(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1488[]; + void TokenFunc1489(x64Operand &operand, int tokenPos); + void TokenFunc1495(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1495[]; + void TokenFunc1496(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1503[]; + void TokenFunc1504(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1504[]; + void TokenFunc1505(x64Operand &operand, int tokenPos); + void TokenFunc1513(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1513[]; + void TokenFunc1514(x64Operand &operand, int tokenPos); + void TokenFunc1520(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1520[]; + void TokenFunc1521(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1528[]; + void TokenFunc1529(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1529[]; + void TokenFunc1530(x64Operand &operand, int tokenPos); + void TokenFunc1538(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1538[]; + void TokenFunc1539(x64Operand &operand, int tokenPos); + void TokenFunc1543(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1543[]; + void TokenFunc1544(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1549[]; + void TokenFunc1550(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1550[]; + void TokenFunc1551(x64Operand &operand, int tokenPos); + void TokenFunc1557(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1557[]; + void TokenFunc1558(x64Operand &operand, int tokenPos); + void TokenFunc1564(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1564[]; + void TokenFunc1565(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1572[]; + void TokenFunc1573(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1573[]; + void TokenFunc1574(x64Operand &operand, int tokenPos); + void TokenFunc1582(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1582[]; + void TokenFunc1583(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1586[]; + void TokenFunc1587(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1587[]; + void TokenFunc1588(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1593[]; + void TokenFunc1594(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1594[]; + void TokenFunc1595(x64Operand &operand, int tokenPos); + void TokenFunc1601(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1601[]; + void TokenFunc1602(x64Operand &operand, int tokenPos); + void TokenFunc1608(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1608[]; + void TokenFunc1609(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1614[]; + void TokenFunc1615(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1615[]; + void TokenFunc1616(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1623[]; + void TokenFunc1624(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1624[]; + void TokenFunc1625(x64Operand &operand, int tokenPos); + void TokenFunc1633(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1633[]; + void TokenFunc1634(x64Operand &operand, int tokenPos); + void TokenFunc1642(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1642[]; + void TokenFunc1643(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1648[]; + void TokenFunc1649(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1649[]; + void TokenFunc1650(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1657[]; + void TokenFunc1658(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1658[]; + void TokenFunc1659(x64Operand &operand, int tokenPos); + void TokenFunc1667(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1667[]; + void TokenFunc1668(x64Operand &operand, int tokenPos); + void TokenFunc1676(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1676[]; + void TokenFunc1677(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1682[]; + void TokenFunc1683(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1683[]; + void TokenFunc1684(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1691[]; + void TokenFunc1692(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1692[]; + void TokenFunc1693(x64Operand &operand, int tokenPos); + void TokenFunc1701(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1701[]; + void TokenFunc1702(x64Operand &operand, int tokenPos); + void TokenFunc1710(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1710[]; + void TokenFunc1711(x64Operand &operand, int tokenPos); + void TokenFunc1715(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1715[]; + void TokenFunc1716(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1721[]; + void TokenFunc1722(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1722[]; + void TokenFunc1723(x64Operand &operand, int tokenPos); + void TokenFunc1729(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1729[]; + void TokenFunc1730(x64Operand &operand, int tokenPos); + void TokenFunc1736(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1736[]; + void TokenFunc1737(x64Operand &operand, int tokenPos); + void TokenFunc1743(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1743[]; + void TokenFunc1744(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1751[]; + void TokenFunc1752(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1752[]; + void TokenFunc1753(x64Operand &operand, int tokenPos); + void TokenFunc1761(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1761[]; + void TokenFunc1762(x64Operand &operand, int tokenPos); + void TokenFunc1770(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1770[]; + void TokenFunc1771(x64Operand &operand, int tokenPos); + void TokenFunc1777(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1777[]; + void TokenFunc1778(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1785[]; + void TokenFunc1786(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1786[]; + void TokenFunc1787(x64Operand &operand, int tokenPos); + void TokenFunc1795(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1795[]; + void TokenFunc1796(x64Operand &operand, int tokenPos); + void TokenFunc1804(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1804[]; + void TokenFunc1805(x64Operand &operand, int tokenPos); + void TokenFunc1811(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1811[]; + void TokenFunc1812(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1819[]; + void TokenFunc1820(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1820[]; + void TokenFunc1821(x64Operand &operand, int tokenPos); + void TokenFunc1829(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1829[]; + void TokenFunc1830(x64Operand &operand, int tokenPos); + void TokenFunc1838(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1838[]; + void TokenFunc1839(x64Operand &operand, int tokenPos); + void TokenFunc1843(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1843[]; + void TokenFunc1844(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1849[]; + void TokenFunc1850(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1850[]; + void TokenFunc1851(x64Operand &operand, int tokenPos); + void TokenFunc1857(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1857[]; + void TokenFunc1858(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1864[]; + void TokenFunc1865(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1872[]; + void TokenFunc1873(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1873[]; + void TokenFunc1874(x64Operand &operand, int tokenPos); + void TokenFunc1882(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1882[]; + void TokenFunc1883(x64Operand &operand, int tokenPos); + void TokenFunc1889(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1889[]; + void TokenFunc1890(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1897[]; + void TokenFunc1898(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1898[]; + void TokenFunc1899(x64Operand &operand, int tokenPos); + void TokenFunc1907(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1907[]; + void TokenFunc1908(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1916[]; + void TokenFunc1917(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1926[]; + void TokenFunc1927(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1927[]; + void TokenFunc1928(x64Operand &operand, int tokenPos); + void TokenFunc1938(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1938[]; + void TokenFunc1939(x64Operand &operand, int tokenPos); + void TokenFunc1945(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1945[]; + void TokenFunc1946(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1953[]; + void TokenFunc1954(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1954[]; + void TokenFunc1955(x64Operand &operand, int tokenPos); + void TokenFunc1963(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1963[]; + void TokenFunc1964(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1972[]; + void TokenFunc1973(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1982[]; + void TokenFunc1983(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1983[]; + void TokenFunc1984(x64Operand &operand, int tokenPos); + void TokenFunc1994(x64Operand &operand, int tokenPos); + static x64Token tokenBranches1994[]; + void TokenFunc1995(x64Operand &operand, int tokenPos); + void TokenFunc2001(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2001[]; + void TokenFunc2002(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2009[]; + void TokenFunc2010(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2010[]; + void TokenFunc2011(x64Operand &operand, int tokenPos); + void TokenFunc2019(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2019[]; + void TokenFunc2020(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2028[]; + void TokenFunc2029(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2038[]; + void TokenFunc2039(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2039[]; + void TokenFunc2040(x64Operand &operand, int tokenPos); + void TokenFunc2050(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2050[]; + void TokenFunc2051(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2055[]; + static x64Token tokenBranches2056[]; + void TokenFunc2057(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2057[]; + void TokenFunc2058(x64Operand &operand, int tokenPos); + void TokenFunc2062(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2062[]; + static x64Token tokenBranches2063[]; + void TokenFunc2064(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2064[]; + static x64Token tokenBranches2065[]; + void TokenFunc2066(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2066[]; + void TokenFunc2067(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2072[]; + void TokenFunc2073(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2073[]; + void TokenFunc2074(x64Operand &operand, int tokenPos); + void TokenFunc2078(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2078[]; + static x64Token tokenBranches2079[]; + void TokenFunc2080(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2080[]; + static x64Token tokenBranches2081[]; + void TokenFunc2082(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2082[]; + void TokenFunc2083(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2088[]; + void TokenFunc2089(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2089[]; + void TokenFunc2090(x64Operand &operand, int tokenPos); + void TokenFunc2096(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2096[]; + static x64Token tokenBranches2097[]; + void TokenFunc2098(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2098[]; + static x64Token tokenBranches2099[]; + void TokenFunc2100(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2100[]; + void TokenFunc2101(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2108[]; + void TokenFunc2109(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2109[]; + void TokenFunc2110(x64Operand &operand, int tokenPos); + void TokenFunc2116(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2116[]; + static x64Token tokenBranches2117[]; + void TokenFunc2118(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2118[]; + static x64Token tokenBranches2119[]; + void TokenFunc2120(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2120[]; + void TokenFunc2121(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2128[]; + void TokenFunc2129(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2129[]; + void TokenFunc2130(x64Operand &operand, int tokenPos); + void TokenFunc2136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2136[]; + static x64Token tokenBranches2137[]; + void TokenFunc2138(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2138[]; + static x64Token tokenBranches2139[]; + void TokenFunc2140(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2140[]; + void TokenFunc2141(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2148[]; + void TokenFunc2149(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2149[]; + void TokenFunc2150(x64Operand &operand, int tokenPos); + void TokenFunc2156(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2156[]; + static x64Token tokenBranches2157[]; + void TokenFunc2158(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2158[]; + static x64Token tokenBranches2159[]; + void TokenFunc2160(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2160[]; + void TokenFunc2161(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2168[]; + void TokenFunc2169(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2169[]; + void TokenFunc2170(x64Operand &operand, int tokenPos); + void TokenFunc2176(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2176[]; + static x64Token tokenBranches2177[]; + void TokenFunc2178(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2178[]; + static x64Token tokenBranches2179[]; + void TokenFunc2180(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2180[]; + void TokenFunc2181(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2188[]; + void TokenFunc2189(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2189[]; + void TokenFunc2190(x64Operand &operand, int tokenPos); + void TokenFunc2196(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2196[]; + static x64Token tokenBranches2197[]; + void TokenFunc2198(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2198[]; + static x64Token tokenBranches2199[]; + void TokenFunc2200(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2200[]; + void TokenFunc2201(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2208[]; + void TokenFunc2209(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2209[]; + void TokenFunc2210(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2216[]; + static x64Token tokenBranches2217[]; + void TokenFunc2218(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2218[]; + void TokenFunc2219(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2225[]; + static x64Token tokenBranches2226[]; + void TokenFunc2227(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2227[]; + void TokenFunc2228(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2234[]; + static x64Token tokenBranches2235[]; + void TokenFunc2236(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2236[]; + void TokenFunc2237(x64Operand &operand, int tokenPos); + void TokenFunc2241(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2241[]; + static x64Token tokenBranches2242[]; + void TokenFunc2243(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2243[]; + static x64Token tokenBranches2244[]; + void TokenFunc2245(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2245[]; + void TokenFunc2246(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2251[]; + void TokenFunc2252(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2252[]; + void TokenFunc2253(x64Operand &operand, int tokenPos); + void TokenFunc2257(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2257[]; + static x64Token tokenBranches2258[]; + void TokenFunc2259(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2259[]; + static x64Token tokenBranches2260[]; + void TokenFunc2261(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2261[]; + void TokenFunc2262(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2267[]; + void TokenFunc2268(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2268[]; + void TokenFunc2269(x64Operand &operand, int tokenPos); + void TokenFunc2275(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2275[]; + static x64Token tokenBranches2276[]; + void TokenFunc2277(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2277[]; + static x64Token tokenBranches2278[]; + void TokenFunc2279(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2279[]; + void TokenFunc2280(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2287[]; + void TokenFunc2288(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2288[]; + void TokenFunc2289(x64Operand &operand, int tokenPos); + void TokenFunc2295(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2295[]; + static x64Token tokenBranches2296[]; + void TokenFunc2297(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2297[]; + static x64Token tokenBranches2298[]; + void TokenFunc2299(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2299[]; + void TokenFunc2300(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2307[]; + void TokenFunc2308(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2308[]; + void TokenFunc2309(x64Operand &operand, int tokenPos); + void TokenFunc2315(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2315[]; + static x64Token tokenBranches2316[]; + void TokenFunc2317(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2317[]; + static x64Token tokenBranches2318[]; + void TokenFunc2319(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2319[]; + void TokenFunc2320(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2327[]; + void TokenFunc2328(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2328[]; + void TokenFunc2329(x64Operand &operand, int tokenPos); + void TokenFunc2335(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2335[]; + static x64Token tokenBranches2336[]; + void TokenFunc2337(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2337[]; + static x64Token tokenBranches2338[]; + void TokenFunc2339(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2339[]; + void TokenFunc2340(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2347[]; + void TokenFunc2348(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2348[]; + void TokenFunc2349(x64Operand &operand, int tokenPos); + void TokenFunc2354(x64Operand &operand, int tokenPos); + void TokenFunc2361(x64Operand &operand, int tokenPos); + void TokenFunc2366(x64Operand &operand, int tokenPos); + void TokenFunc2373(x64Operand &operand, int tokenPos); + void TokenFunc2378(x64Operand &operand, int tokenPos); + void TokenFunc2387(x64Operand &operand, int tokenPos); + void TokenFunc2394(x64Operand &operand, int tokenPos); + void TokenFunc2403(x64Operand &operand, int tokenPos); + void TokenFunc2410(x64Operand &operand, int tokenPos); + void TokenFunc2419(x64Operand &operand, int tokenPos); + void TokenFunc2426(x64Operand &operand, int tokenPos); + void TokenFunc2435(x64Operand &operand, int tokenPos); + void TokenFunc2442(x64Operand &operand, int tokenPos); + void TokenFunc2449(x64Operand &operand, int tokenPos); + void TokenFunc2456(x64Operand &operand, int tokenPos); + void TokenFunc2463(x64Operand &operand, int tokenPos); + void TokenFunc2472(x64Operand &operand, int tokenPos); + void TokenFunc2479(x64Operand &operand, int tokenPos); + void TokenFunc2488(x64Operand &operand, int tokenPos); + void TokenFunc2495(x64Operand &operand, int tokenPos); + void TokenFunc2502(x64Operand &operand, int tokenPos); + void TokenFunc2507(x64Operand &operand, int tokenPos); + void TokenFunc2514(x64Operand &operand, int tokenPos); + void TokenFunc2519(x64Operand &operand, int tokenPos); + void TokenFunc2528(x64Operand &operand, int tokenPos); + void TokenFunc2535(x64Operand &operand, int tokenPos); + void TokenFunc2544(x64Operand &operand, int tokenPos); + void TokenFunc2551(x64Operand &operand, int tokenPos); + void TokenFunc2560(x64Operand &operand, int tokenPos); + void TokenFunc2567(x64Operand &operand, int tokenPos); + void TokenFunc2576(x64Operand &operand, int tokenPos); + void TokenFunc2583(x64Operand &operand, int tokenPos); + void TokenFunc2589(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2589[]; + void TokenFunc2590(x64Operand &operand, int tokenPos); + void TokenFunc2598(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2598[]; + void TokenFunc2599(x64Operand &operand, int tokenPos); + void TokenFunc2605(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2605[]; + void TokenFunc2606(x64Operand &operand, int tokenPos); + void TokenFunc2614(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2614[]; + void TokenFunc2615(x64Operand &operand, int tokenPos); + void TokenFunc2621(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2621[]; + void TokenFunc2622(x64Operand &operand, int tokenPos); + void TokenFunc2630(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2630[]; + void TokenFunc2631(x64Operand &operand, int tokenPos); + void TokenFunc2639(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2639[]; + void TokenFunc2640(x64Operand &operand, int tokenPos); + void TokenFunc2648(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2648[]; + void TokenFunc2649(x64Operand &operand, int tokenPos); + void TokenFunc2659(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2659[]; + void TokenFunc2660(x64Operand &operand, int tokenPos); + void TokenFunc2668(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2668[]; + void TokenFunc2669(x64Operand &operand, int tokenPos); + void TokenFunc2679(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2679[]; + void TokenFunc2680(x64Operand &operand, int tokenPos); + void TokenFunc2688(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2688[]; + void TokenFunc2689(x64Operand &operand, int tokenPos); + void TokenFunc2699(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2699[]; + void TokenFunc2700(x64Operand &operand, int tokenPos); + void TokenFunc2708(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2708[]; + void TokenFunc2709(x64Operand &operand, int tokenPos); + void TokenFunc2719(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2719[]; + void TokenFunc2720(x64Operand &operand, int tokenPos); + void TokenFunc2728(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2728[]; + void TokenFunc2729(x64Operand &operand, int tokenPos); + void TokenFunc2739(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2739[]; + void TokenFunc2740(x64Operand &operand, int tokenPos); + void TokenFunc2748(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2748[]; + void TokenFunc2749(x64Operand &operand, int tokenPos); + void TokenFunc2759(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2759[]; + void TokenFunc2760(x64Operand &operand, int tokenPos); + void TokenFunc2768(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2768[]; + void TokenFunc2769(x64Operand &operand, int tokenPos); + void TokenFunc2777(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2777[]; + void TokenFunc2778(x64Operand &operand, int tokenPos); + void TokenFunc2784(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2784[]; + void TokenFunc2785(x64Operand &operand, int tokenPos); + void TokenFunc2793(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2793[]; + void TokenFunc2794(x64Operand &operand, int tokenPos); + void TokenFunc2800(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2800[]; + void TokenFunc2801(x64Operand &operand, int tokenPos); + void TokenFunc2811(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2811[]; + void TokenFunc2812(x64Operand &operand, int tokenPos); + void TokenFunc2820(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2820[]; + void TokenFunc2821(x64Operand &operand, int tokenPos); + void TokenFunc2831(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2831[]; + void TokenFunc2832(x64Operand &operand, int tokenPos); + void TokenFunc2840(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2840[]; + void TokenFunc2841(x64Operand &operand, int tokenPos); + void TokenFunc2851(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2851[]; + void TokenFunc2852(x64Operand &operand, int tokenPos); + void TokenFunc2860(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2860[]; + void TokenFunc2861(x64Operand &operand, int tokenPos); + void TokenFunc2871(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2871[]; + void TokenFunc2872(x64Operand &operand, int tokenPos); + void TokenFunc2880(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2880[]; + void TokenFunc2881(x64Operand &operand, int tokenPos); + void TokenFunc2887(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2887[]; + void TokenFunc2888(x64Operand &operand, int tokenPos); + void TokenFunc2896(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2896[]; + void TokenFunc2897(x64Operand &operand, int tokenPos); + void TokenFunc2903(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2903[]; + void TokenFunc2904(x64Operand &operand, int tokenPos); + void TokenFunc2912(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2912[]; + void TokenFunc2913(x64Operand &operand, int tokenPos); + void TokenFunc2919(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2919[]; + void TokenFunc2920(x64Operand &operand, int tokenPos); + void TokenFunc2930(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2930[]; + void TokenFunc2931(x64Operand &operand, int tokenPos); + void TokenFunc2939(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2939[]; + void TokenFunc2940(x64Operand &operand, int tokenPos); + void TokenFunc2950(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2950[]; + void TokenFunc2951(x64Operand &operand, int tokenPos); + void TokenFunc2959(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2959[]; + void TokenFunc2960(x64Operand &operand, int tokenPos); + void TokenFunc2970(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2970[]; + void TokenFunc2971(x64Operand &operand, int tokenPos); + void TokenFunc2979(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2979[]; + void TokenFunc2980(x64Operand &operand, int tokenPos); + void TokenFunc2990(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2990[]; + void TokenFunc2991(x64Operand &operand, int tokenPos); + void TokenFunc2999(x64Operand &operand, int tokenPos); + static x64Token tokenBranches2999[]; + void TokenFunc3000(x64Operand &operand, int tokenPos); + void TokenFunc3008(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3008[]; + void TokenFunc3009(x64Operand &operand, int tokenPos); + void TokenFunc3017(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3017[]; + void TokenFunc3018(x64Operand &operand, int tokenPos); + void TokenFunc3026(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3026[]; + void TokenFunc3027(x64Operand &operand, int tokenPos); + void TokenFunc3037(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3037[]; + void TokenFunc3038(x64Operand &operand, int tokenPos); + void TokenFunc3046(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3046[]; + void TokenFunc3047(x64Operand &operand, int tokenPos); + void TokenFunc3057(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3057[]; + void TokenFunc3058(x64Operand &operand, int tokenPos); + void TokenFunc3066(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3066[]; + void TokenFunc3067(x64Operand &operand, int tokenPos); + void TokenFunc3075(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3075[]; + void TokenFunc3076(x64Operand &operand, int tokenPos); + void TokenFunc3082(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3082[]; + void TokenFunc3083(x64Operand &operand, int tokenPos); + void TokenFunc3091(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3091[]; + void TokenFunc3092(x64Operand &operand, int tokenPos); + void TokenFunc3098(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3098[]; + void TokenFunc3099(x64Operand &operand, int tokenPos); + void TokenFunc3109(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3109[]; + void TokenFunc3110(x64Operand &operand, int tokenPos); + void TokenFunc3118(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3118[]; + void TokenFunc3119(x64Operand &operand, int tokenPos); + void TokenFunc3129(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3129[]; + void TokenFunc3130(x64Operand &operand, int tokenPos); + void TokenFunc3138(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3138[]; + void TokenFunc3139(x64Operand &operand, int tokenPos); + void TokenFunc3149(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3149[]; + void TokenFunc3150(x64Operand &operand, int tokenPos); + void TokenFunc3158(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3158[]; + void TokenFunc3159(x64Operand &operand, int tokenPos); + void TokenFunc3169(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3169[]; + void TokenFunc3170(x64Operand &operand, int tokenPos); + void TokenFunc3178(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3178[]; + void TokenFunc3179(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3181[]; + void TokenFunc3182(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3184[]; + void TokenFunc3185(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3187[]; + void TokenFunc3188(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3190[]; + void TokenFunc3191(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3195[]; + void TokenFunc3196(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3200[]; + void TokenFunc3201(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3205[]; + void TokenFunc3206(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3210[]; + void TokenFunc3211(x64Operand &operand, int tokenPos); + void TokenFunc3213(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3213[]; + void TokenFunc3214(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3217[]; + static x64Token tokenBranches3218[]; + void TokenFunc3219(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3222[]; + static x64Token tokenBranches3223[]; + void TokenFunc3224(x64Operand &operand, int tokenPos); + void TokenFunc3228(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3228[]; + void TokenFunc3229(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3234[]; + static x64Token tokenBranches3235[]; + void TokenFunc3236(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3241[]; + static x64Token tokenBranches3242[]; + void TokenFunc3243(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3245[]; + static x64Token tokenBranches3246[]; + void TokenFunc3247(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3247[]; + void TokenFunc3248(x64Operand &operand, int tokenPos); + void TokenFunc3250(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3250[]; + void TokenFunc3251(x64Operand &operand, int tokenPos); + void TokenFunc3255(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3255[]; + void TokenFunc3256(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3259[]; + void TokenFunc3260(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3260[]; + void TokenFunc3261(x64Operand &operand, int tokenPos); + void TokenFunc3264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3264[]; + void TokenFunc3265(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3268[]; + void TokenFunc3269(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3269[]; + void TokenFunc3270(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3275[]; + void TokenFunc3276(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3276[]; + void TokenFunc3277(x64Operand &operand, int tokenPos); + void TokenFunc3282(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3282[]; + void TokenFunc3283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3288[]; + void TokenFunc3289(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3289[]; + void TokenFunc3290(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3293[]; + void TokenFunc3294(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3294[]; + void TokenFunc3295(x64Operand &operand, int tokenPos); + void TokenFunc3299(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3299[]; + void TokenFunc3300(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3305[]; + void TokenFunc3306(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3306[]; + void TokenFunc3307(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3312[]; + void TokenFunc3313(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3313[]; + void TokenFunc3314(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3319[]; + void TokenFunc3320(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3320[]; + void TokenFunc3321(x64Operand &operand, int tokenPos); + void TokenFunc3327(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3327[]; + void TokenFunc3328(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3335[]; + void TokenFunc3336(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3336[]; + void TokenFunc3337(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3344[]; + void TokenFunc3345(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3345[]; + void TokenFunc3346(x64Operand &operand, int tokenPos); + void TokenFunc3350(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3350[]; + void TokenFunc3351(x64Operand &operand, int tokenPos); + void TokenFunc3355(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3355[]; + void TokenFunc3356(x64Operand &operand, int tokenPos); + void TokenFunc3360(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3360[]; + void TokenFunc3361(x64Operand &operand, int tokenPos); + void TokenFunc3367(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3367[]; + void TokenFunc3368(x64Operand &operand, int tokenPos); + void TokenFunc3374(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3374[]; + void TokenFunc3375(x64Operand &operand, int tokenPos); + void TokenFunc3381(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3381[]; + void TokenFunc3382(x64Operand &operand, int tokenPos); + void TokenFunc3386(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3386[]; + void TokenFunc3387(x64Operand &operand, int tokenPos); + void TokenFunc3391(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3391[]; + void TokenFunc3392(x64Operand &operand, int tokenPos); + void TokenFunc3398(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3398[]; + void TokenFunc3399(x64Operand &operand, int tokenPos); + void TokenFunc3405(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3405[]; + void TokenFunc3406(x64Operand &operand, int tokenPos); + void TokenFunc3412(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3412[]; + void TokenFunc3413(x64Operand &operand, int tokenPos); + void TokenFunc3419(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3419[]; + void TokenFunc3420(x64Operand &operand, int tokenPos); + void TokenFunc3428(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3428[]; + void TokenFunc3429(x64Operand &operand, int tokenPos); + void TokenFunc3437(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3437[]; + void TokenFunc3438(x64Operand &operand, int tokenPos); + void TokenFunc3442(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3442[]; + void TokenFunc3443(x64Operand &operand, int tokenPos); + void TokenFunc3447(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3447[]; + void TokenFunc3448(x64Operand &operand, int tokenPos); + void TokenFunc3452(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3452[]; + void TokenFunc3453(x64Operand &operand, int tokenPos); + void TokenFunc3459(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3459[]; + void TokenFunc3460(x64Operand &operand, int tokenPos); + void TokenFunc3466(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3466[]; + void TokenFunc3467(x64Operand &operand, int tokenPos); + void TokenFunc3473(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3473[]; + void TokenFunc3474(x64Operand &operand, int tokenPos); + void TokenFunc3478(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3478[]; + void TokenFunc3479(x64Operand &operand, int tokenPos); + void TokenFunc3483(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3483[]; + void TokenFunc3484(x64Operand &operand, int tokenPos); + void TokenFunc3490(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3490[]; + void TokenFunc3491(x64Operand &operand, int tokenPos); + void TokenFunc3497(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3497[]; + void TokenFunc3498(x64Operand &operand, int tokenPos); + void TokenFunc3504(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3504[]; + void TokenFunc3505(x64Operand &operand, int tokenPos); + void TokenFunc3511(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3511[]; + void TokenFunc3512(x64Operand &operand, int tokenPos); + void TokenFunc3520(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3520[]; + void TokenFunc3521(x64Operand &operand, int tokenPos); + void TokenFunc3529(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3529[]; + void TokenFunc3530(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3533[]; + void TokenFunc3534(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3534[]; + void TokenFunc3535(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3540[]; + void TokenFunc3541(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3541[]; + void TokenFunc3542(x64Operand &operand, int tokenPos); + void TokenFunc3548(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3548[]; + void TokenFunc3549(x64Operand &operand, int tokenPos); + void TokenFunc3555(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3555[]; + void TokenFunc3556(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3561[]; + void TokenFunc3562(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3562[]; + void TokenFunc3563(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3570[]; + void TokenFunc3571(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3571[]; + void TokenFunc3572(x64Operand &operand, int tokenPos); + void TokenFunc3580(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3580[]; + void TokenFunc3581(x64Operand &operand, int tokenPos); + void TokenFunc3589(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3589[]; + void TokenFunc3590(x64Operand &operand, int tokenPos); + void TokenFunc3594(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3594[]; + void TokenFunc3595(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3600[]; + void TokenFunc3601(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3601[]; + void TokenFunc3602(x64Operand &operand, int tokenPos); + void TokenFunc3608(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3608[]; + void TokenFunc3609(x64Operand &operand, int tokenPos); + void TokenFunc3615(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3615[]; + void TokenFunc3616(x64Operand &operand, int tokenPos); + void TokenFunc3622(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3622[]; + void TokenFunc3623(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3630[]; + void TokenFunc3631(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3631[]; + void TokenFunc3632(x64Operand &operand, int tokenPos); + void TokenFunc3640(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3640[]; + void TokenFunc3641(x64Operand &operand, int tokenPos); + void TokenFunc3649(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3649[]; + void TokenFunc3650(x64Operand &operand, int tokenPos); + void TokenFunc3654(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3654[]; + void TokenFunc3655(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3660[]; + void TokenFunc3661(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3661[]; + void TokenFunc3662(x64Operand &operand, int tokenPos); + void TokenFunc3668(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3668[]; + void TokenFunc3669(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3676[]; + void TokenFunc3677(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3677[]; + void TokenFunc3678(x64Operand &operand, int tokenPos); + void TokenFunc3682(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3682[]; + void TokenFunc3683(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3688[]; + void TokenFunc3689(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3689[]; + void TokenFunc3690(x64Operand &operand, int tokenPos); + void TokenFunc3696(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3696[]; + void TokenFunc3697(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3704[]; + void TokenFunc3705(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3705[]; + void TokenFunc3706(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3709[]; + void TokenFunc3710(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3710[]; + void TokenFunc3711(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3716[]; + void TokenFunc3717(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3717[]; + void TokenFunc3718(x64Operand &operand, int tokenPos); + void TokenFunc3724(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3724[]; + void TokenFunc3725(x64Operand &operand, int tokenPos); + void TokenFunc3731(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3731[]; + void TokenFunc3732(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3736[]; + static x64Token tokenBranches3737[]; + void TokenFunc3738(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3738[]; + void TokenFunc3739(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3746[]; + void TokenFunc3747(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3747[]; + void TokenFunc3748(x64Operand &operand, int tokenPos); + void TokenFunc3756(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3756[]; + void TokenFunc3757(x64Operand &operand, int tokenPos); + void TokenFunc3765(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3765[]; + void TokenFunc3766(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3770[]; + static x64Token tokenBranches3771[]; + void TokenFunc3772(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3772[]; + void TokenFunc3773(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3780[]; + void TokenFunc3781(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3781[]; + void TokenFunc3782(x64Operand &operand, int tokenPos); + void TokenFunc3790(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3790[]; + void TokenFunc3791(x64Operand &operand, int tokenPos); + void TokenFunc3799(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3799[]; + void TokenFunc3800(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3805[]; + void TokenFunc3806(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3806[]; + void TokenFunc3807(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3814[]; + void TokenFunc3815(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3815[]; + void TokenFunc3816(x64Operand &operand, int tokenPos); + void TokenFunc3824(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3824[]; + void TokenFunc3825(x64Operand &operand, int tokenPos); + void TokenFunc3833(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3833[]; + void TokenFunc3834(x64Operand &operand, int tokenPos); + void TokenFunc3838(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3838[]; + void TokenFunc3839(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3844[]; + void TokenFunc3845(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3845[]; + void TokenFunc3846(x64Operand &operand, int tokenPos); + void TokenFunc3852(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3852[]; + void TokenFunc3853(x64Operand &operand, int tokenPos); + void TokenFunc3859(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3859[]; + void TokenFunc3860(x64Operand &operand, int tokenPos); + void TokenFunc3866(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3866[]; + void TokenFunc3867(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3874[]; + void TokenFunc3875(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3875[]; + void TokenFunc3876(x64Operand &operand, int tokenPos); + void TokenFunc3884(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3884[]; + void TokenFunc3885(x64Operand &operand, int tokenPos); + void TokenFunc3893(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3893[]; + void TokenFunc3894(x64Operand &operand, int tokenPos); + void TokenFunc3900(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3900[]; + void TokenFunc3901(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3908[]; + void TokenFunc3909(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3909[]; + void TokenFunc3910(x64Operand &operand, int tokenPos); + void TokenFunc3918(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3918[]; + void TokenFunc3919(x64Operand &operand, int tokenPos); + void TokenFunc3927(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3927[]; + void TokenFunc3928(x64Operand &operand, int tokenPos); + void TokenFunc3934(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3934[]; + void TokenFunc3935(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3942[]; + void TokenFunc3943(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3943[]; + void TokenFunc3944(x64Operand &operand, int tokenPos); + void TokenFunc3952(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3952[]; + void TokenFunc3953(x64Operand &operand, int tokenPos); + void TokenFunc3961(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3961[]; + void TokenFunc3962(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3965[]; + void TokenFunc3966(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3966[]; + void TokenFunc3967(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3972[]; + void TokenFunc3973(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3973[]; + void TokenFunc3974(x64Operand &operand, int tokenPos); + void TokenFunc3980(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3980[]; + void TokenFunc3981(x64Operand &operand, int tokenPos); + void TokenFunc3987(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3987[]; + void TokenFunc3988(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3992[]; + static x64Token tokenBranches3993[]; + void TokenFunc3994(x64Operand &operand, int tokenPos); + static x64Token tokenBranches3994[]; + void TokenFunc3995(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4002[]; + void TokenFunc4003(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4003[]; + void TokenFunc4004(x64Operand &operand, int tokenPos); + void TokenFunc4012(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4012[]; + void TokenFunc4013(x64Operand &operand, int tokenPos); + void TokenFunc4021(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4021[]; + void TokenFunc4022(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4026[]; + static x64Token tokenBranches4027[]; + void TokenFunc4028(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4028[]; + void TokenFunc4029(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4036[]; + void TokenFunc4037(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4037[]; + void TokenFunc4038(x64Operand &operand, int tokenPos); + void TokenFunc4046(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4046[]; + void TokenFunc4047(x64Operand &operand, int tokenPos); + void TokenFunc4055(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4055[]; + void TokenFunc4056(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4061[]; + void TokenFunc4062(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4062[]; + void TokenFunc4063(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4070[]; + void TokenFunc4071(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4071[]; + void TokenFunc4072(x64Operand &operand, int tokenPos); + void TokenFunc4080(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4080[]; + void TokenFunc4081(x64Operand &operand, int tokenPos); + void TokenFunc4089(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4089[]; + void TokenFunc4090(x64Operand &operand, int tokenPos); + void TokenFunc4094(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4094[]; + void TokenFunc4095(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4100[]; + void TokenFunc4101(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4101[]; + void TokenFunc4102(x64Operand &operand, int tokenPos); + void TokenFunc4108(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4108[]; + void TokenFunc4109(x64Operand &operand, int tokenPos); + void TokenFunc4115(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4115[]; + void TokenFunc4116(x64Operand &operand, int tokenPos); + void TokenFunc4122(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4122[]; + void TokenFunc4123(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4130[]; + void TokenFunc4131(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4131[]; + void TokenFunc4132(x64Operand &operand, int tokenPos); + void TokenFunc4140(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4140[]; + void TokenFunc4141(x64Operand &operand, int tokenPos); + void TokenFunc4149(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4149[]; + void TokenFunc4150(x64Operand &operand, int tokenPos); + void TokenFunc4156(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4156[]; + void TokenFunc4157(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4164[]; + void TokenFunc4165(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4165[]; + void TokenFunc4166(x64Operand &operand, int tokenPos); + void TokenFunc4174(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4174[]; + void TokenFunc4175(x64Operand &operand, int tokenPos); + void TokenFunc4183(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4183[]; + void TokenFunc4184(x64Operand &operand, int tokenPos); + void TokenFunc4190(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4190[]; + void TokenFunc4191(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4198[]; + void TokenFunc4199(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4199[]; + void TokenFunc4200(x64Operand &operand, int tokenPos); + void TokenFunc4208(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4208[]; + void TokenFunc4209(x64Operand &operand, int tokenPos); + void TokenFunc4217(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4217[]; + void TokenFunc4218(x64Operand &operand, int tokenPos); + void TokenFunc4222(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4222[]; + void TokenFunc4223(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4228[]; + void TokenFunc4229(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4229[]; + void TokenFunc4230(x64Operand &operand, int tokenPos); + void TokenFunc4236(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4236[]; + void TokenFunc4237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4244[]; + void TokenFunc4245(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4245[]; + void TokenFunc4246(x64Operand &operand, int tokenPos); + void TokenFunc4250(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4250[]; + void TokenFunc4251(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4256[]; + void TokenFunc4257(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4257[]; + void TokenFunc4258(x64Operand &operand, int tokenPos); + void TokenFunc4264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4264[]; + void TokenFunc4265(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4272[]; + void TokenFunc4273(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4273[]; + void TokenFunc4274(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4277[]; + void TokenFunc4278(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4278[]; + void TokenFunc4279(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4284[]; + void TokenFunc4285(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4285[]; + void TokenFunc4286(x64Operand &operand, int tokenPos); + void TokenFunc4292(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4292[]; + void TokenFunc4293(x64Operand &operand, int tokenPos); + void TokenFunc4299(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4299[]; + void TokenFunc4300(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4305[]; + void TokenFunc4306(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4306[]; + void TokenFunc4307(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4314[]; + void TokenFunc4315(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4315[]; + void TokenFunc4316(x64Operand &operand, int tokenPos); + void TokenFunc4324(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4324[]; + void TokenFunc4325(x64Operand &operand, int tokenPos); + void TokenFunc4333(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4333[]; + void TokenFunc4334(x64Operand &operand, int tokenPos); + void TokenFunc4338(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4338[]; + void TokenFunc4339(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4344[]; + void TokenFunc4345(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4345[]; + void TokenFunc4346(x64Operand &operand, int tokenPos); + void TokenFunc4352(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4352[]; + void TokenFunc4353(x64Operand &operand, int tokenPos); + void TokenFunc4359(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4359[]; + void TokenFunc4360(x64Operand &operand, int tokenPos); + void TokenFunc4366(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4366[]; + void TokenFunc4367(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4374[]; + void TokenFunc4375(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4375[]; + void TokenFunc4376(x64Operand &operand, int tokenPos); + void TokenFunc4384(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4384[]; + void TokenFunc4385(x64Operand &operand, int tokenPos); + void TokenFunc4393(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4393[]; + void TokenFunc4394(x64Operand &operand, int tokenPos); + void TokenFunc4398(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4398[]; + void TokenFunc4399(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4404[]; + void TokenFunc4405(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4405[]; + void TokenFunc4406(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4412[]; + void TokenFunc4413(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4420[]; + void TokenFunc4421(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4421[]; + void TokenFunc4422(x64Operand &operand, int tokenPos); + void TokenFunc4428(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4428[]; + void TokenFunc4429(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4436[]; + void TokenFunc4437(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4437[]; + void TokenFunc4438(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4446[]; + void TokenFunc4447(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4456[]; + void TokenFunc4457(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4457[]; + void TokenFunc4458(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4462[]; + static x64Token tokenBranches4463[]; + void TokenFunc4464(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4464[]; + void TokenFunc4465(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4469[]; + static x64Token tokenBranches4470[]; + void TokenFunc4471(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4471[]; + void TokenFunc4472(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4478[]; + static x64Token tokenBranches4479[]; + void TokenFunc4480(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4480[]; + void TokenFunc4481(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4487[]; + static x64Token tokenBranches4488[]; + void TokenFunc4489(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4489[]; + void TokenFunc4490(x64Operand &operand, int tokenPos); + void TokenFunc4494(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4494[]; + static x64Token tokenBranches4495[]; + void TokenFunc4496(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4496[]; + static x64Token tokenBranches4497[]; + void TokenFunc4498(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4498[]; + void TokenFunc4499(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4504[]; + void TokenFunc4505(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4505[]; + void TokenFunc4506(x64Operand &operand, int tokenPos); + void TokenFunc4510(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4510[]; + static x64Token tokenBranches4511[]; + void TokenFunc4512(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4512[]; + static x64Token tokenBranches4513[]; + void TokenFunc4514(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4514[]; + void TokenFunc4515(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4520[]; + void TokenFunc4521(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4521[]; + void TokenFunc4522(x64Operand &operand, int tokenPos); + void TokenFunc4526(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4526[]; + static x64Token tokenBranches4527[]; + void TokenFunc4528(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4528[]; + static x64Token tokenBranches4529[]; + void TokenFunc4530(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4530[]; + void TokenFunc4531(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4536[]; + void TokenFunc4537(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4537[]; + void TokenFunc4538(x64Operand &operand, int tokenPos); + void TokenFunc4544(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4544[]; + static x64Token tokenBranches4545[]; + void TokenFunc4546(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4546[]; + static x64Token tokenBranches4547[]; + void TokenFunc4548(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4548[]; + void TokenFunc4549(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4556[]; + void TokenFunc4557(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4557[]; + void TokenFunc4558(x64Operand &operand, int tokenPos); + void TokenFunc4564(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4564[]; + static x64Token tokenBranches4565[]; + void TokenFunc4566(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4566[]; + static x64Token tokenBranches4567[]; + void TokenFunc4568(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4568[]; + void TokenFunc4569(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4576[]; + void TokenFunc4577(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4577[]; + void TokenFunc4578(x64Operand &operand, int tokenPos); + void TokenFunc4584(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4584[]; + static x64Token tokenBranches4585[]; + void TokenFunc4586(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4586[]; + static x64Token tokenBranches4587[]; + void TokenFunc4588(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4588[]; + void TokenFunc4589(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4596[]; + void TokenFunc4597(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4597[]; + void TokenFunc4598(x64Operand &operand, int tokenPos); + void TokenFunc4602(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4602[]; + static x64Token tokenBranches4603[]; + void TokenFunc4604(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4604[]; + static x64Token tokenBranches4605[]; + void TokenFunc4606(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4606[]; + void TokenFunc4607(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4612[]; + void TokenFunc4613(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4613[]; + void TokenFunc4614(x64Operand &operand, int tokenPos); + void TokenFunc4618(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4618[]; + static x64Token tokenBranches4619[]; + void TokenFunc4620(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4620[]; + static x64Token tokenBranches4621[]; + void TokenFunc4622(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4622[]; + void TokenFunc4623(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4628[]; + void TokenFunc4629(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4629[]; + void TokenFunc4630(x64Operand &operand, int tokenPos); + void TokenFunc4636(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4636[]; + static x64Token tokenBranches4637[]; + void TokenFunc4638(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4638[]; + static x64Token tokenBranches4639[]; + void TokenFunc4640(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4640[]; + void TokenFunc4641(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4648[]; + void TokenFunc4649(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4649[]; + void TokenFunc4650(x64Operand &operand, int tokenPos); + void TokenFunc4656(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4656[]; + static x64Token tokenBranches4657[]; + void TokenFunc4658(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4658[]; + static x64Token tokenBranches4659[]; + void TokenFunc4660(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4660[]; + void TokenFunc4661(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4668[]; + void TokenFunc4669(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4669[]; + void TokenFunc4670(x64Operand &operand, int tokenPos); + void TokenFunc4675(x64Operand &operand, int tokenPos); + void TokenFunc4680(x64Operand &operand, int tokenPos); + void TokenFunc4687(x64Operand &operand, int tokenPos); + void TokenFunc4694(x64Operand &operand, int tokenPos); + void TokenFunc4701(x64Operand &operand, int tokenPos); + void TokenFunc4706(x64Operand &operand, int tokenPos); + void TokenFunc4713(x64Operand &operand, int tokenPos); + void TokenFunc4718(x64Operand &operand, int tokenPos); + void TokenFunc4725(x64Operand &operand, int tokenPos); + void TokenFunc4730(x64Operand &operand, int tokenPos); + void TokenFunc4739(x64Operand &operand, int tokenPos); + void TokenFunc4746(x64Operand &operand, int tokenPos); + void TokenFunc4755(x64Operand &operand, int tokenPos); + void TokenFunc4762(x64Operand &operand, int tokenPos); + void TokenFunc4771(x64Operand &operand, int tokenPos); + void TokenFunc4778(x64Operand &operand, int tokenPos); + void TokenFunc4785(x64Operand &operand, int tokenPos); + void TokenFunc4790(x64Operand &operand, int tokenPos); + void TokenFunc4797(x64Operand &operand, int tokenPos); + void TokenFunc4802(x64Operand &operand, int tokenPos); + void TokenFunc4811(x64Operand &operand, int tokenPos); + void TokenFunc4818(x64Operand &operand, int tokenPos); + void TokenFunc4827(x64Operand &operand, int tokenPos); + void TokenFunc4834(x64Operand &operand, int tokenPos); + void TokenFunc4840(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4840[]; + void TokenFunc4841(x64Operand &operand, int tokenPos); + void TokenFunc4847(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4847[]; + void TokenFunc4848(x64Operand &operand, int tokenPos); + void TokenFunc4856(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4856[]; + void TokenFunc4857(x64Operand &operand, int tokenPos); + void TokenFunc4865(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4865[]; + void TokenFunc4866(x64Operand &operand, int tokenPos); + void TokenFunc4874(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4874[]; + void TokenFunc4875(x64Operand &operand, int tokenPos); + void TokenFunc4881(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4881[]; + void TokenFunc4882(x64Operand &operand, int tokenPos); + void TokenFunc4890(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4890[]; + void TokenFunc4891(x64Operand &operand, int tokenPos); + void TokenFunc4897(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4897[]; + void TokenFunc4898(x64Operand &operand, int tokenPos); + void TokenFunc4906(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4906[]; + void TokenFunc4907(x64Operand &operand, int tokenPos); + void TokenFunc4913(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4913[]; + void TokenFunc4914(x64Operand &operand, int tokenPos); + void TokenFunc4924(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4924[]; + void TokenFunc4925(x64Operand &operand, int tokenPos); + void TokenFunc4933(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4933[]; + void TokenFunc4934(x64Operand &operand, int tokenPos); + void TokenFunc4944(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4944[]; + void TokenFunc4945(x64Operand &operand, int tokenPos); + void TokenFunc4953(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4953[]; + void TokenFunc4954(x64Operand &operand, int tokenPos); + void TokenFunc4964(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4964[]; + void TokenFunc4965(x64Operand &operand, int tokenPos); + void TokenFunc4973(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4973[]; + void TokenFunc4974(x64Operand &operand, int tokenPos); + void TokenFunc4982(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4982[]; + void TokenFunc4983(x64Operand &operand, int tokenPos); + void TokenFunc4989(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4989[]; + void TokenFunc4990(x64Operand &operand, int tokenPos); + void TokenFunc4998(x64Operand &operand, int tokenPos); + static x64Token tokenBranches4998[]; + void TokenFunc4999(x64Operand &operand, int tokenPos); + void TokenFunc5005(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5005[]; + void TokenFunc5006(x64Operand &operand, int tokenPos); + void TokenFunc5016(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5016[]; + void TokenFunc5017(x64Operand &operand, int tokenPos); + void TokenFunc5025(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5025[]; + void TokenFunc5026(x64Operand &operand, int tokenPos); + void TokenFunc5036(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5036[]; + void TokenFunc5037(x64Operand &operand, int tokenPos); + void TokenFunc5045(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5045[]; + void TokenFunc5046(x64Operand &operand, int tokenPos); + void TokenFunc5052(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5052[]; + void TokenFunc5053(x64Operand &operand, int tokenPos); + void TokenFunc5059(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5059[]; + void TokenFunc5060(x64Operand &operand, int tokenPos); + void TokenFunc5068(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5068[]; + void TokenFunc5069(x64Operand &operand, int tokenPos); + void TokenFunc5077(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5077[]; + void TokenFunc5078(x64Operand &operand, int tokenPos); + void TokenFunc5086(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5086[]; + void TokenFunc5087(x64Operand &operand, int tokenPos); + void TokenFunc5093(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5093[]; + void TokenFunc5094(x64Operand &operand, int tokenPos); + void TokenFunc5102(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5102[]; + void TokenFunc5103(x64Operand &operand, int tokenPos); + void TokenFunc5109(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5109[]; + void TokenFunc5110(x64Operand &operand, int tokenPos); + void TokenFunc5118(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5118[]; + void TokenFunc5119(x64Operand &operand, int tokenPos); + void TokenFunc5125(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5125[]; + void TokenFunc5126(x64Operand &operand, int tokenPos); + void TokenFunc5136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5136[]; + void TokenFunc5137(x64Operand &operand, int tokenPos); + void TokenFunc5145(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5145[]; + void TokenFunc5146(x64Operand &operand, int tokenPos); + void TokenFunc5156(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5156[]; + void TokenFunc5157(x64Operand &operand, int tokenPos); + void TokenFunc5165(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5165[]; + void TokenFunc5166(x64Operand &operand, int tokenPos); + void TokenFunc5176(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5176[]; + void TokenFunc5177(x64Operand &operand, int tokenPos); + void TokenFunc5185(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5185[]; + void TokenFunc5186(x64Operand &operand, int tokenPos); + void TokenFunc5194(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5194[]; + void TokenFunc5195(x64Operand &operand, int tokenPos); + void TokenFunc5201(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5201[]; + void TokenFunc5202(x64Operand &operand, int tokenPos); + void TokenFunc5210(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5210[]; + void TokenFunc5211(x64Operand &operand, int tokenPos); + void TokenFunc5217(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5217[]; + void TokenFunc5218(x64Operand &operand, int tokenPos); + void TokenFunc5228(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5228[]; + void TokenFunc5229(x64Operand &operand, int tokenPos); + void TokenFunc5237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5237[]; + void TokenFunc5238(x64Operand &operand, int tokenPos); + void TokenFunc5248(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5248[]; + void TokenFunc5249(x64Operand &operand, int tokenPos); + void TokenFunc5257(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5257[]; + void TokenFunc5258(x64Operand &operand, int tokenPos); + void TokenFunc5259(x64Operand &operand, int tokenPos); + void TokenFunc5260(x64Operand &operand, int tokenPos); + void TokenFunc5261(x64Operand &operand, int tokenPos); + void TokenFunc5262(x64Operand &operand, int tokenPos); + void TokenFunc5263(x64Operand &operand, int tokenPos); + void TokenFunc5264(x64Operand &operand, int tokenPos); + void TokenFunc5265(x64Operand &operand, int tokenPos); + void TokenFunc5266(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5267[]; + void TokenFunc5268(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5269[]; + void TokenFunc5270(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5271[]; + void TokenFunc5272(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5272[]; + static x64Token tokenBranches5273[]; + static x64Token tokenBranches5274[]; + static Coding tokenCoding5275_16[]; + static Coding tokenCoding5275_17[]; + static Coding tokenCoding5275_18[]; + static Coding tokenCoding5275_19[]; + void TokenFunc5275(x64Operand &operand, int tokenPos); + void TokenFunc5276(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5276[]; + static x64Token tokenBranches5277[]; + static x64Token tokenBranches5278[]; + static Coding tokenCoding5279_16[]; + static Coding tokenCoding5279_17[]; + static Coding tokenCoding5279_18[]; + static Coding tokenCoding5279_19[]; + void TokenFunc5279(x64Operand &operand, int tokenPos); + void TokenFunc5280(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5280[]; + static x64Token tokenBranches5281[]; + static x64Token tokenBranches5282[]; + static Coding tokenCoding5283_16[]; + static Coding tokenCoding5283_17[]; + static Coding tokenCoding5283_18[]; + static Coding tokenCoding5283_19[]; + void TokenFunc5283(x64Operand &operand, int tokenPos); + static Coding tokenCoding5287_16[]; + static Coding tokenCoding5287_17[]; + static Coding tokenCoding5287_18[]; + static Coding tokenCoding5287_19[]; + void TokenFunc5287(x64Operand &operand, int tokenPos); + static Coding tokenCoding5291_16[]; + static Coding tokenCoding5291_17[]; + static Coding tokenCoding5291_18[]; + static Coding tokenCoding5291_19[]; + void TokenFunc5291(x64Operand &operand, int tokenPos); + static Coding tokenCoding5295_16[]; + static Coding tokenCoding5295_17[]; + static Coding tokenCoding5295_18[]; + static Coding tokenCoding5295_19[]; + void TokenFunc5295(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5296[]; + void TokenFunc5297(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5297[]; + static x64Token tokenBranches5298[]; + static x64Token tokenBranches5299[]; + static Coding tokenCoding5300_16[]; + static Coding tokenCoding5300_17[]; + static Coding tokenCoding5300_18[]; + static Coding tokenCoding5300_19[]; + void TokenFunc5300(x64Operand &operand, int tokenPos); + void TokenFunc5301(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5301[]; + static x64Token tokenBranches5302[]; + static x64Token tokenBranches5303[]; + static Coding tokenCoding5304_16[]; + static Coding tokenCoding5304_17[]; + static Coding tokenCoding5304_18[]; + static Coding tokenCoding5304_19[]; + void TokenFunc5304(x64Operand &operand, int tokenPos); + void TokenFunc5305(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5305[]; + static x64Token tokenBranches5306[]; + static x64Token tokenBranches5307[]; + static Coding tokenCoding5308_16[]; + static Coding tokenCoding5308_17[]; + static Coding tokenCoding5308_18[]; + static Coding tokenCoding5308_19[]; + void TokenFunc5308(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5309[]; + static x64Token tokenBranches5310[]; + static x64Token tokenBranches5311[]; + static x64Token tokenBranches5312[]; + void TokenFunc5313(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5314[]; + static x64Token tokenBranches5315[]; + static x64Token tokenBranches5316[]; + void TokenFunc5317(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5318[]; + static x64Token tokenBranches5319[]; + static x64Token tokenBranches5320[]; + void TokenFunc5321(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5322[]; + static x64Token tokenBranches5323[]; + static x64Token tokenBranches5324[]; + void TokenFunc5325(x64Operand &operand, int tokenPos); + void TokenFunc5326(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5326[]; + static x64Token tokenBranches5327[]; + static x64Token tokenBranches5328[]; + static Coding tokenCoding5329_16[]; + static Coding tokenCoding5329_17[]; + static Coding tokenCoding5329_18[]; + static Coding tokenCoding5329_19[]; + void TokenFunc5329(x64Operand &operand, int tokenPos); + void TokenFunc5330(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5330[]; + static x64Token tokenBranches5331[]; + static x64Token tokenBranches5332[]; + static Coding tokenCoding5333_16[]; + static Coding tokenCoding5333_17[]; + static Coding tokenCoding5333_23[]; + static Coding tokenCoding5333_18[]; + static Coding tokenCoding5333_19[]; + void TokenFunc5333(x64Operand &operand, int tokenPos); + void TokenFunc5334(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5334[]; + static x64Token tokenBranches5335[]; + static x64Token tokenBranches5336[]; + static Coding tokenCoding5337_16[]; + static Coding tokenCoding5337_17[]; + static Coding tokenCoding5337_18[]; + static Coding tokenCoding5337_19[]; + void TokenFunc5337(x64Operand &operand, int tokenPos); + void TokenFunc5338(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5338[]; + static x64Token tokenBranches5339[]; + static x64Token tokenBranches5340[]; + static Coding tokenCoding5341_16[]; + static Coding tokenCoding5341_17[]; + static Coding tokenCoding5341_18[]; + static Coding tokenCoding5341_19[]; + void TokenFunc5341(x64Operand &operand, int tokenPos); + void TokenFunc5342(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5342[]; + static x64Token tokenBranches5343[]; + static x64Token tokenBranches5344[]; + static Coding tokenCoding5345_16[]; + static Coding tokenCoding5345_17[]; + static Coding tokenCoding5345_18[]; + static Coding tokenCoding5345_19[]; + void TokenFunc5345(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5346[]; + static x64Token tokenBranches5347[]; + static x64Token tokenBranches5348[]; + static Coding tokenCoding5349_16[]; + static Coding tokenCoding5349_17[]; + static Coding tokenCoding5349_18[]; + static Coding tokenCoding5349_19[]; + void TokenFunc5349(x64Operand &operand, int tokenPos); + static Coding tokenCoding5353_16[]; + static Coding tokenCoding5353_17[]; + static Coding tokenCoding5353_23[]; + static Coding tokenCoding5353_18[]; + static Coding tokenCoding5353_19[]; + void TokenFunc5353(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5354[]; + static x64Token tokenBranches5355[]; + static x64Token tokenBranches5356[]; + static Coding tokenCoding5357_16[]; + static Coding tokenCoding5357_17[]; + static Coding tokenCoding5357_18[]; + static Coding tokenCoding5357_19[]; + void TokenFunc5357(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5358[]; + static x64Token tokenBranches5359[]; + static x64Token tokenBranches5360[]; + static Coding tokenCoding5361_16[]; + static Coding tokenCoding5361_17[]; + static Coding tokenCoding5361_18[]; + static Coding tokenCoding5361_19[]; + void TokenFunc5361(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5362[]; + static x64Token tokenBranches5363[]; + static x64Token tokenBranches5364[]; + static Coding tokenCoding5365_16[]; + static Coding tokenCoding5365_17[]; + static Coding tokenCoding5365_18[]; + static Coding tokenCoding5365_19[]; + void TokenFunc5365(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5366[]; + static x64Token tokenBranches5367[]; + static x64Token tokenBranches5368[]; + static x64Token tokenBranches5369[]; + static Coding tokenCoding5370_16[]; + static Coding tokenCoding5370_17[]; + static Coding tokenCoding5370_19[]; + void TokenFunc5370(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5371[]; + static x64Token tokenBranches5372[]; + static x64Token tokenBranches5373[]; + static x64Token tokenBranches5374[]; + static Coding tokenCoding5375_16[]; + static Coding tokenCoding5375_17[]; + static Coding tokenCoding5375_19[]; + void TokenFunc5375(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5379[]; + static Coding tokenCoding5380_16[]; + static Coding tokenCoding5380_17[]; + static Coding tokenCoding5380_19[]; + void TokenFunc5380(x64Operand &operand, int tokenPos); + static Coding tokenCoding5385_16[]; + static Coding tokenCoding5385_17[]; + static Coding tokenCoding5385_19[]; + void TokenFunc5385(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5386[]; + static x64Token tokenBranches5387[]; + static x64Token tokenBranches5388[]; + static x64Token tokenBranches5389[]; + static Coding tokenCoding5390_16[]; + static Coding tokenCoding5390_17[]; + static Coding tokenCoding5390_19[]; + void TokenFunc5390(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5394[]; + static Coding tokenCoding5395_16[]; + static Coding tokenCoding5395_17[]; + static Coding tokenCoding5395_19[]; + void TokenFunc5395(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5399[]; + static Coding tokenCoding5400_16[]; + static Coding tokenCoding5400_17[]; + static Coding tokenCoding5400_19[]; + void TokenFunc5400(x64Operand &operand, int tokenPos); + static Coding tokenCoding5405_16[]; + static Coding tokenCoding5405_17[]; + static Coding tokenCoding5405_19[]; + void TokenFunc5405(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5406[]; + static x64Token tokenBranches5407[]; + static x64Token tokenBranches5408[]; + static x64Token tokenBranches5409[]; + static Coding tokenCoding5410_16[]; + static Coding tokenCoding5410_17[]; + static Coding tokenCoding5410_19[]; + void TokenFunc5410(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5414[]; + static Coding tokenCoding5415_16[]; + static Coding tokenCoding5415_17[]; + static Coding tokenCoding5415_19[]; + void TokenFunc5415(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5419[]; + static Coding tokenCoding5420_16[]; + static Coding tokenCoding5420_17[]; + static Coding tokenCoding5420_19[]; + void TokenFunc5420(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5424[]; + static Coding tokenCoding5425_16[]; + static Coding tokenCoding5425_17[]; + static Coding tokenCoding5425_19[]; + void TokenFunc5425(x64Operand &operand, int tokenPos); + static Coding tokenCoding5430_16[]; + static Coding tokenCoding5430_17[]; + static Coding tokenCoding5430_19[]; + void TokenFunc5430(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5431[]; + static x64Token tokenBranches5432[]; + static x64Token tokenBranches5433[]; + static Coding tokenCoding5434_16[]; + static Coding tokenCoding5434_17[]; + static Coding tokenCoding5434_19[]; + void TokenFunc5434(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5435[]; + static x64Token tokenBranches5436[]; + static x64Token tokenBranches5437[]; + static Coding tokenCoding5438_16[]; + static Coding tokenCoding5438_17[]; + static Coding tokenCoding5438_19[]; + void TokenFunc5438(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5441[]; + static Coding tokenCoding5442_16[]; + static Coding tokenCoding5442_17[]; + static Coding tokenCoding5442_19[]; + void TokenFunc5442(x64Operand &operand, int tokenPos); + static Coding tokenCoding5446_16[]; + static Coding tokenCoding5446_17[]; + static Coding tokenCoding5446_19[]; + void TokenFunc5446(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5447[]; + static x64Token tokenBranches5448[]; + static x64Token tokenBranches5449[]; + static Coding tokenCoding5450_16[]; + static Coding tokenCoding5450_17[]; + static Coding tokenCoding5450_19[]; + void TokenFunc5450(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5453[]; + static Coding tokenCoding5454_16[]; + static Coding tokenCoding5454_17[]; + static Coding tokenCoding5454_19[]; + void TokenFunc5454(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5457[]; + static Coding tokenCoding5458_16[]; + static Coding tokenCoding5458_17[]; + static Coding tokenCoding5458_19[]; + void TokenFunc5458(x64Operand &operand, int tokenPos); + static Coding tokenCoding5462_16[]; + static Coding tokenCoding5462_17[]; + static Coding tokenCoding5462_19[]; + void TokenFunc5462(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5463[]; + static x64Token tokenBranches5464[]; + static x64Token tokenBranches5465[]; + static Coding tokenCoding5466_16[]; + static Coding tokenCoding5466_17[]; + static Coding tokenCoding5466_19[]; + void TokenFunc5466(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5469[]; + static Coding tokenCoding5470_16[]; + static Coding tokenCoding5470_17[]; + static Coding tokenCoding5470_19[]; + void TokenFunc5470(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5473[]; + static Coding tokenCoding5474_16[]; + static Coding tokenCoding5474_17[]; + static Coding tokenCoding5474_19[]; + void TokenFunc5474(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5477[]; + static Coding tokenCoding5478_16[]; + static Coding tokenCoding5478_17[]; + static Coding tokenCoding5478_19[]; + void TokenFunc5478(x64Operand &operand, int tokenPos); + static Coding tokenCoding5482_16[]; + static Coding tokenCoding5482_17[]; + static Coding tokenCoding5482_19[]; + void TokenFunc5482(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5483[]; + static x64Token tokenBranches5484[]; + static x64Token tokenBranches5485[]; + static x64Token tokenBranches5486[]; + static x64Token tokenBranches5487[]; + static Coding tokenCoding5488_16[]; + static Coding tokenCoding5488_17[]; + static Coding tokenCoding5488_19[]; + void TokenFunc5488(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5489[]; + static x64Token tokenBranches5490[]; + static x64Token tokenBranches5491[]; + static x64Token tokenBranches5492[]; + static Coding tokenCoding5493_16[]; + static Coding tokenCoding5493_17[]; + static Coding tokenCoding5493_19[]; + void TokenFunc5493(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5494[]; + static x64Token tokenBranches5495[]; + static x64Token tokenBranches5496[]; + static x64Token tokenBranches5497[]; + static Coding tokenCoding5498_16[]; + static Coding tokenCoding5498_17[]; + static Coding tokenCoding5498_19[]; + void TokenFunc5498(x64Operand &operand, int tokenPos); + static Coding tokenCoding5502_16[]; + static Coding tokenCoding5502_17[]; + static Coding tokenCoding5502_18[]; + static Coding tokenCoding5502_19[]; + void TokenFunc5502(x64Operand &operand, int tokenPos); + static Coding tokenCoding5506_16[]; + static Coding tokenCoding5506_17[]; + static Coding tokenCoding5506_18[]; + static Coding tokenCoding5506_19[]; + void TokenFunc5506(x64Operand &operand, int tokenPos); + static Coding tokenCoding5510_16[]; + static Coding tokenCoding5510_17[]; + static Coding tokenCoding5510_18[]; + static Coding tokenCoding5510_19[]; + void TokenFunc5510(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5511[]; + static Coding tokenCoding5512_16[]; + static Coding tokenCoding5512_17[]; + static Coding tokenCoding5512_19[]; + void TokenFunc5512(x64Operand &operand, int tokenPos); + void TokenFunc5513(x64Operand &operand, int tokenPos); + void TokenFunc5514(x64Operand &operand, int tokenPos); + void TokenFunc5515(x64Operand &operand, int tokenPos); + static Coding tokenCoding5516_16[]; + static Coding tokenCoding5516_17[]; + static Coding tokenCoding5516_19[]; + void TokenFunc5516(x64Operand &operand, int tokenPos); + static Coding tokenCoding5517_16[]; + static Coding tokenCoding5517_17[]; + static Coding tokenCoding5517_19[]; + void TokenFunc5517(x64Operand &operand, int tokenPos); + static Coding tokenCoding5518_16[]; + static Coding tokenCoding5518_17[]; + static Coding tokenCoding5518_19[]; + void TokenFunc5518(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5519[]; + static Coding tokenCoding5520_16[]; + static Coding tokenCoding5520_17[]; + static Coding tokenCoding5520_19[]; + void TokenFunc5520(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5521[]; + static Coding tokenCoding5522_16[]; + static Coding tokenCoding5522_17[]; + static Coding tokenCoding5522_19[]; + void TokenFunc5522(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5523[]; + static Coding tokenCoding5524_16[]; + static Coding tokenCoding5524_17[]; + static Coding tokenCoding5524_19[]; + void TokenFunc5524(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5525[]; + static Coding tokenCoding5526_16[]; + static Coding tokenCoding5526_17[]; + static Coding tokenCoding5526_19[]; + void TokenFunc5526(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5527[]; + static Coding tokenCoding5528_16[]; + static Coding tokenCoding5528_17[]; + static Coding tokenCoding5528_19[]; + void TokenFunc5528(x64Operand &operand, int tokenPos); + static Coding tokenCoding5529_16[]; + static Coding tokenCoding5529_17[]; + static Coding tokenCoding5529_19[]; + void TokenFunc5529(x64Operand &operand, int tokenPos); + static Coding tokenCoding5530_16[]; + static Coding tokenCoding5530_17[]; + static Coding tokenCoding5530_19[]; + void TokenFunc5530(x64Operand &operand, int tokenPos); + static Coding tokenCoding5531_16[]; + static Coding tokenCoding5531_17[]; + static Coding tokenCoding5531_19[]; + void TokenFunc5531(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5532[]; + static Coding tokenCoding5533_16[]; + static Coding tokenCoding5533_17[]; + static Coding tokenCoding5533_19[]; + void TokenFunc5533(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5534[]; + static Coding tokenCoding5535_16[]; + static Coding tokenCoding5535_17[]; + static Coding tokenCoding5535_19[]; + void TokenFunc5535(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5536[]; + static Coding tokenCoding5537_16[]; + static Coding tokenCoding5537_17[]; + static Coding tokenCoding5537_19[]; + void TokenFunc5537(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5538[]; + static Coding tokenCoding5539_16[]; + static Coding tokenCoding5539_17[]; + static Coding tokenCoding5539_19[]; + void TokenFunc5539(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5540[]; + static x64Token tokenBranches5541[]; + static x64Token tokenBranches5542[]; + void TokenFunc5543(x64Operand &operand, int tokenPos); + void TokenFunc5544(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5544[]; + static x64Token tokenBranches5545[]; + void TokenFunc5546(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5548[]; + static Coding tokenCoding5549_16[]; + static Coding tokenCoding5549_17[]; + static Coding tokenCoding5549_19[]; + void TokenFunc5549(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5550[]; + static Coding tokenCoding5551_16[]; + static Coding tokenCoding5551_17[]; + static Coding tokenCoding5551_19[]; + void TokenFunc5551(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5552[]; + void TokenFunc5553(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5553[]; + static x64Token tokenBranches5554[]; + void TokenFunc5555(x64Operand &operand, int tokenPos); + void TokenFunc5557(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5558[]; + static x64Token tokenBranches5559[]; + static Coding tokenCoding5560_16[]; + static Coding tokenCoding5560_17[]; + static Coding tokenCoding5560_19[]; + void TokenFunc5560(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5561[]; + static Coding tokenCoding5562_16[]; + static Coding tokenCoding5562_17[]; + static Coding tokenCoding5562_19[]; + void TokenFunc5562(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5563[]; + static x64Token tokenBranches5564[]; + static Coding tokenCoding5565_16[]; + static Coding tokenCoding5565_17[]; + void TokenFunc5565(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5566[]; + static x64Token tokenBranches5567[]; + void TokenFunc5568(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5569[]; + void TokenFunc5570(x64Operand &operand, int tokenPos); + void TokenFunc5572(x64Operand &operand, int tokenPos); + void TokenFunc5573(x64Operand &operand, int tokenPos); + void TokenFunc5574(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5575[]; + void TokenFunc5576(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5576[]; + static x64Token tokenBranches5577[]; + static x64Token tokenBranches5578[]; + static Coding tokenCoding5579_16[]; + static Coding tokenCoding5579_17[]; + static Coding tokenCoding5579_18[]; + static Coding tokenCoding5579_19[]; + void TokenFunc5579(x64Operand &operand, int tokenPos); + void TokenFunc5580(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5580[]; + static x64Token tokenBranches5581[]; + static x64Token tokenBranches5582[]; + static Coding tokenCoding5583_16[]; + static Coding tokenCoding5583_17[]; + static Coding tokenCoding5583_18[]; + static Coding tokenCoding5583_19[]; + void TokenFunc5583(x64Operand &operand, int tokenPos); + void TokenFunc5584(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5584[]; + static x64Token tokenBranches5585[]; + static x64Token tokenBranches5586[]; + static Coding tokenCoding5587_16[]; + static Coding tokenCoding5587_17[]; + static Coding tokenCoding5587_18[]; + static Coding tokenCoding5587_19[]; + void TokenFunc5587(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5588[]; + static x64Token tokenBranches5589[]; + static Coding tokenCoding5590_16[]; + static Coding tokenCoding5590_17[]; + static Coding tokenCoding5590_18[]; + static Coding tokenCoding5590_19[]; + void TokenFunc5590(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5591[]; + void TokenFunc5592(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5592[]; + static x64Token tokenBranches5593[]; + static Coding tokenCoding5594_16[]; + static Coding tokenCoding5594_17[]; + static Coding tokenCoding5594_18[]; + static Coding tokenCoding5594_19[]; + void TokenFunc5594(x64Operand &operand, int tokenPos); + void TokenFunc5595(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5595[]; + static x64Token tokenBranches5596[]; + static Coding tokenCoding5597_16[]; + static Coding tokenCoding5597_17[]; + static Coding tokenCoding5597_18[]; + static Coding tokenCoding5597_19[]; + void TokenFunc5597(x64Operand &operand, int tokenPos); + static Coding tokenCoding5600_16[]; + static Coding tokenCoding5600_17[]; + static Coding tokenCoding5600_18[]; + static Coding tokenCoding5600_19[]; + void TokenFunc5600(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5603[]; + static Coding tokenCoding5604_16[]; + static Coding tokenCoding5604_17[]; + static Coding tokenCoding5604_18[]; + static Coding tokenCoding5604_19[]; + void TokenFunc5604(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5607[]; + static Coding tokenCoding5608_16[]; + static Coding tokenCoding5608_17[]; + static Coding tokenCoding5608_18[]; + static Coding tokenCoding5608_19[]; + void TokenFunc5608(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5611[]; + static Coding tokenCoding5612_16[]; + static Coding tokenCoding5612_17[]; + static Coding tokenCoding5612_18[]; + static Coding tokenCoding5612_19[]; + void TokenFunc5612(x64Operand &operand, int tokenPos); + void TokenFunc5613(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5613[]; + static x64Token tokenBranches5614[]; + static Coding tokenCoding5615_16[]; + static Coding tokenCoding5615_17[]; + static Coding tokenCoding5615_18[]; + static Coding tokenCoding5615_19[]; + void TokenFunc5615(x64Operand &operand, int tokenPos); + static Coding tokenCoding5618_16[]; + static Coding tokenCoding5618_17[]; + static Coding tokenCoding5618_18[]; + static Coding tokenCoding5618_19[]; + void TokenFunc5618(x64Operand &operand, int tokenPos); + static Coding tokenCoding5621_16[]; + static Coding tokenCoding5621_17[]; + static Coding tokenCoding5621_18[]; + static Coding tokenCoding5621_19[]; + void TokenFunc5621(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5624[]; + static Coding tokenCoding5625_16[]; + static Coding tokenCoding5625_17[]; + static Coding tokenCoding5625_18[]; + static Coding tokenCoding5625_19[]; + void TokenFunc5625(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5628[]; + static Coding tokenCoding5629_16[]; + static Coding tokenCoding5629_17[]; + static Coding tokenCoding5629_18[]; + static Coding tokenCoding5629_19[]; + void TokenFunc5629(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5632[]; + static Coding tokenCoding5633_16[]; + static Coding tokenCoding5633_17[]; + static Coding tokenCoding5633_18[]; + static Coding tokenCoding5633_19[]; + void TokenFunc5633(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5634[]; + static x64Token tokenBranches5635[]; + static x64Token tokenBranches5636[]; + static Coding tokenCoding5637_16[]; + static Coding tokenCoding5637_17[]; + static Coding tokenCoding5637_19[]; + void TokenFunc5637(x64Operand &operand, int tokenPos); + static Coding tokenCoding5640_16[]; + static Coding tokenCoding5640_17[]; + static Coding tokenCoding5640_19[]; + void TokenFunc5640(x64Operand &operand, int tokenPos); + static Coding tokenCoding5643_16[]; + static Coding tokenCoding5643_17[]; + static Coding tokenCoding5643_19[]; + void TokenFunc5643(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5644[]; + static x64Token tokenBranches5645[]; + static x64Token tokenBranches5646[]; + static x64Token tokenBranches5647[]; + static Coding tokenCoding5648_16[]; + static Coding tokenCoding5648_17[]; + static Coding tokenCoding5648_19[]; + void TokenFunc5648(x64Operand &operand, int tokenPos); + static Coding tokenCoding5653_16[]; + static Coding tokenCoding5653_17[]; + static Coding tokenCoding5653_19[]; + void TokenFunc5653(x64Operand &operand, int tokenPos); + static Coding tokenCoding5657_16[]; + static Coding tokenCoding5657_17[]; + static Coding tokenCoding5657_19[]; + void TokenFunc5657(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5658[]; + static x64Token tokenBranches5659[]; + static Coding tokenCoding5660_16[]; + static Coding tokenCoding5660_17[]; + static Coding tokenCoding5660_19[]; + void TokenFunc5660(x64Operand &operand, int tokenPos); + static Coding tokenCoding5663_16[]; + static Coding tokenCoding5663_17[]; + static Coding tokenCoding5663_19[]; + void TokenFunc5663(x64Operand &operand, int tokenPos); + static Coding tokenCoding5666_16[]; + static Coding tokenCoding5666_17[]; + static Coding tokenCoding5666_19[]; + void TokenFunc5666(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5667[]; + static x64Token tokenBranches5668[]; + static x64Token tokenBranches5669[]; + static x64Token tokenBranches5670[]; + static Coding tokenCoding5671_16[]; + static Coding tokenCoding5671_17[]; + static Coding tokenCoding5671_19[]; + void TokenFunc5671(x64Operand &operand, int tokenPos); + static Coding tokenCoding5676_16[]; + static Coding tokenCoding5676_17[]; + static Coding tokenCoding5676_19[]; + void TokenFunc5676(x64Operand &operand, int tokenPos); + static Coding tokenCoding5680_16[]; + static Coding tokenCoding5680_17[]; + static Coding tokenCoding5680_19[]; + void TokenFunc5680(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5681[]; + static x64Token tokenBranches5682[]; + static Coding tokenCoding5683_16[]; + static Coding tokenCoding5683_17[]; + static Coding tokenCoding5683_19[]; + void TokenFunc5683(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5686[]; + static Coding tokenCoding5687_16[]; + static Coding tokenCoding5687_17[]; + static Coding tokenCoding5687_19[]; + void TokenFunc5687(x64Operand &operand, int tokenPos); + static Coding tokenCoding5690_16[]; + static Coding tokenCoding5690_17[]; + static Coding tokenCoding5690_19[]; + void TokenFunc5690(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5691[]; + static x64Token tokenBranches5692[]; + static x64Token tokenBranches5693[]; + static x64Token tokenBranches5694[]; + static Coding tokenCoding5695_16[]; + static Coding tokenCoding5695_17[]; + static Coding tokenCoding5695_19[]; + void TokenFunc5695(x64Operand &operand, int tokenPos); + static Coding tokenCoding5700_16[]; + static Coding tokenCoding5700_17[]; + static Coding tokenCoding5700_19[]; + void TokenFunc5700(x64Operand &operand, int tokenPos); + static Coding tokenCoding5704_16[]; + static Coding tokenCoding5704_17[]; + static Coding tokenCoding5704_19[]; + void TokenFunc5704(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5705[]; + static x64Token tokenBranches5706[]; + static Coding tokenCoding5707_16[]; + static Coding tokenCoding5707_17[]; + static Coding tokenCoding5707_19[]; + void TokenFunc5707(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5710[]; + static Coding tokenCoding5711_16[]; + static Coding tokenCoding5711_17[]; + static Coding tokenCoding5711_19[]; + void TokenFunc5711(x64Operand &operand, int tokenPos); + static Coding tokenCoding5714_16[]; + static Coding tokenCoding5714_17[]; + static Coding tokenCoding5714_19[]; + void TokenFunc5714(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5715[]; + static x64Token tokenBranches5716[]; + static x64Token tokenBranches5717[]; + static x64Token tokenBranches5718[]; + static Coding tokenCoding5719_16[]; + static Coding tokenCoding5719_17[]; + static Coding tokenCoding5719_19[]; + void TokenFunc5719(x64Operand &operand, int tokenPos); + static Coding tokenCoding5724_16[]; + static Coding tokenCoding5724_17[]; + static Coding tokenCoding5724_19[]; + void TokenFunc5724(x64Operand &operand, int tokenPos); + static Coding tokenCoding5728_16[]; + static Coding tokenCoding5728_17[]; + static Coding tokenCoding5728_19[]; + void TokenFunc5728(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5729[]; + static x64Token tokenBranches5730[]; + static x64Token tokenBranches5731[]; + static x64Token tokenBranches5732[]; + void TokenFunc5733(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5733[]; + static x64Token tokenBranches5734[]; + static Coding tokenCoding5735_16[]; + static Coding tokenCoding5735_17[]; + static Coding tokenCoding5735_18[]; + static Coding tokenCoding5735_19[]; + void TokenFunc5735(x64Operand &operand, int tokenPos); + static Coding tokenCoding5741_16[]; + static Coding tokenCoding5741_17[]; + static Coding tokenCoding5741_18[]; + static Coding tokenCoding5741_19[]; + void TokenFunc5741(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5742[]; + static x64Token tokenBranches5743[]; + static x64Token tokenBranches5744[]; + void TokenFunc5745(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5745[]; + static x64Token tokenBranches5746[]; + static Coding tokenCoding5747_16[]; + static Coding tokenCoding5747_17[]; + static Coding tokenCoding5747_18[]; + static Coding tokenCoding5747_19[]; + void TokenFunc5747(x64Operand &operand, int tokenPos); + static Coding tokenCoding5753_16[]; + static Coding tokenCoding5753_17[]; + static Coding tokenCoding5753_18[]; + static Coding tokenCoding5753_19[]; + void TokenFunc5753(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5754[]; + static x64Token tokenBranches5755[]; + static x64Token tokenBranches5756[]; + void TokenFunc5757(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5757[]; + static x64Token tokenBranches5758[]; + static Coding tokenCoding5759_16[]; + static Coding tokenCoding5759_17[]; + static Coding tokenCoding5759_18[]; + static Coding tokenCoding5759_19[]; + void TokenFunc5759(x64Operand &operand, int tokenPos); + static Coding tokenCoding5765_16[]; + static Coding tokenCoding5765_17[]; + static Coding tokenCoding5765_18[]; + static Coding tokenCoding5765_19[]; + void TokenFunc5765(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5766[]; + static Coding tokenCoding5767_16[]; + static Coding tokenCoding5767_17[]; + void TokenFunc5767(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5768[]; + void TokenFunc5769(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5769[]; + static x64Token tokenBranches5770[]; + static Coding tokenCoding5771_16[]; + static Coding tokenCoding5771_17[]; + static Coding tokenCoding5771_18[]; + void TokenFunc5771(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5772[]; + void TokenFunc5773(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5773[]; + static x64Token tokenBranches5774[]; + static Coding tokenCoding5775_16[]; + static Coding tokenCoding5775_17[]; + static Coding tokenCoding5775_18[]; + static Coding tokenCoding5775_19[]; + void TokenFunc5775(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5776[]; + static x64Token tokenBranches5777[]; + static Coding tokenCoding5778_16[]; + static Coding tokenCoding5778_17[]; + static Coding tokenCoding5778_18[]; + static Coding tokenCoding5778_19[]; + void TokenFunc5778(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5779[]; + void TokenFunc5780(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5780[]; + static x64Token tokenBranches5781[]; + static Coding tokenCoding5782_16[]; + static Coding tokenCoding5782_17[]; + static Coding tokenCoding5782_18[]; + static Coding tokenCoding5782_19[]; + void TokenFunc5782(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5783[]; + static x64Token tokenBranches5784[]; + static Coding tokenCoding5785_16[]; + static Coding tokenCoding5785_17[]; + static Coding tokenCoding5785_18[]; + static Coding tokenCoding5785_19[]; + void TokenFunc5785(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5786[]; + void TokenFunc5787(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5787[]; + static x64Token tokenBranches5788[]; + static Coding tokenCoding5789_16[]; + static Coding tokenCoding5789_17[]; + static Coding tokenCoding5789_18[]; + static Coding tokenCoding5789_19[]; + void TokenFunc5789(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5790[]; + static x64Token tokenBranches5791[]; + static Coding tokenCoding5792_16[]; + static Coding tokenCoding5792_17[]; + static Coding tokenCoding5792_18[]; + static Coding tokenCoding5792_19[]; + void TokenFunc5792(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5793[]; + void TokenFunc5794(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5794[]; + static x64Token tokenBranches5795[]; + static Coding tokenCoding5796_16[]; + static Coding tokenCoding5796_17[]; + static Coding tokenCoding5796_18[]; + void TokenFunc5796(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5797[]; + void TokenFunc5798(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5798[]; + static x64Token tokenBranches5799[]; + static Coding tokenCoding5800_16[]; + static Coding tokenCoding5800_17[]; + static Coding tokenCoding5800_18[]; + void TokenFunc5800(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5801[]; + void TokenFunc5802(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5802[]; + static x64Token tokenBranches5803[]; + static Coding tokenCoding5804_16[]; + static Coding tokenCoding5804_17[]; + static Coding tokenCoding5804_18[]; + void TokenFunc5804(x64Operand &operand, int tokenPos); + void TokenFunc5805(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5805[]; + static x64Token tokenBranches5806[]; + static Coding tokenCoding5807_16[]; + static Coding tokenCoding5807_17[]; + static Coding tokenCoding5807_18[]; + void TokenFunc5807(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5808[]; + void TokenFunc5809(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5809[]; + static x64Token tokenBranches5810[]; + static x64Token tokenBranches5811[]; + static Coding tokenCoding5812_16[]; + static Coding tokenCoding5812_17[]; + static Coding tokenCoding5812_18[]; + void TokenFunc5812(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5815[]; + static Coding tokenCoding5816_16[]; + static Coding tokenCoding5816_17[]; + static Coding tokenCoding5816_18[]; + void TokenFunc5816(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5817[]; + void TokenFunc5818(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5818[]; + static x64Token tokenBranches5819[]; + static Coding tokenCoding5820_16[]; + static Coding tokenCoding5820_17[]; + static Coding tokenCoding5820_23[]; + static Coding tokenCoding5820_18[]; + void TokenFunc5820(x64Operand &operand, int tokenPos); + void TokenFunc5821(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5821[]; + static x64Token tokenBranches5822[]; + static Coding tokenCoding5823_16[]; + static Coding tokenCoding5823_17[]; + static Coding tokenCoding5823_23[]; + static Coding tokenCoding5823_18[]; + void TokenFunc5823(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5824[]; + void TokenFunc5825(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5825[]; + static x64Token tokenBranches5826[]; + static x64Token tokenBranches5827[]; + static x64Token tokenBranches5828[]; + static Coding tokenCoding5829_16[]; + static Coding tokenCoding5829_17[]; + static Coding tokenCoding5829_18[]; + void TokenFunc5829(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5830[]; + static x64Token tokenBranches5831[]; + static x64Token tokenBranches5832[]; + static Coding tokenCoding5833_16[]; + static Coding tokenCoding5833_17[]; + static Coding tokenCoding5833_23[]; + static Coding tokenCoding5833_18[]; + static Coding tokenCoding5833_19[]; + void TokenFunc5833(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5834[]; + static x64Token tokenBranches5835[]; + static Coding tokenCoding5836_16[]; + static Coding tokenCoding5836_17[]; + static Coding tokenCoding5836_23[]; + static Coding tokenCoding5836_18[]; + static Coding tokenCoding5836_19[]; + void TokenFunc5836(x64Operand &operand, int tokenPos); + void TokenFunc5837(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5837[]; + static x64Token tokenBranches5838[]; + static Coding tokenCoding5839_16[]; + static Coding tokenCoding5839_17[]; + static Coding tokenCoding5839_23[]; + static Coding tokenCoding5839_18[]; + static Coding tokenCoding5839_19[]; + void TokenFunc5839(x64Operand &operand, int tokenPos); + void TokenFunc5840(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5840[]; + static x64Token tokenBranches5841[]; + static Coding tokenCoding5842_16[]; + static Coding tokenCoding5842_17[]; + static Coding tokenCoding5842_23[]; + static Coding tokenCoding5842_18[]; + static Coding tokenCoding5842_19[]; + void TokenFunc5842(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5843[]; + void TokenFunc5844(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5844[]; + static x64Token tokenBranches5845[]; + static x64Token tokenBranches5846[]; + static x64Token tokenBranches5847[]; + static Coding tokenCoding5848_16[]; + static Coding tokenCoding5848_17[]; + static Coding tokenCoding5848_18[]; + void TokenFunc5848(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5849[]; + void TokenFunc5850(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5850[]; + static x64Token tokenBranches5851[]; + static x64Token tokenBranches5852[]; + static x64Token tokenBranches5853[]; + static Coding tokenCoding5854_16[]; + static Coding tokenCoding5854_17[]; + static Coding tokenCoding5854_18[]; + void TokenFunc5854(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5862[]; + static x64Token tokenBranches5863[]; + static x64Token tokenBranches5864[]; + static Coding tokenCoding5865_16[]; + static Coding tokenCoding5865_17[]; + static Coding tokenCoding5865_18[]; + static Coding tokenCoding5865_19[]; + void TokenFunc5865(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5869[]; + static Coding tokenCoding5870_16[]; + static Coding tokenCoding5870_17[]; + static Coding tokenCoding5870_18[]; + void TokenFunc5870(x64Operand &operand, int tokenPos); + static Coding tokenCoding5871_16[]; + static Coding tokenCoding5871_17[]; + static Coding tokenCoding5871_18[]; + void TokenFunc5871(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5876[]; + void TokenFunc5877(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5877[]; + static x64Token tokenBranches5878[]; + static x64Token tokenBranches5879[]; + void TokenFunc5880(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5883[]; + void TokenFunc5884(x64Operand &operand, int tokenPos); + void TokenFunc5885(x64Operand &operand, int tokenPos); + void TokenFunc5886(x64Operand &operand, int tokenPos); + static Coding tokenCoding5887_16[]; + static Coding tokenCoding5887_17[]; + static Coding tokenCoding5887_18[]; + static Coding tokenCoding5887_19[]; + void TokenFunc5887(x64Operand &operand, int tokenPos); + static Coding tokenCoding5888_16[]; + static Coding tokenCoding5888_17[]; + static Coding tokenCoding5888_18[]; + static Coding tokenCoding5888_19[]; + void TokenFunc5888(x64Operand &operand, int tokenPos); + static Coding tokenCoding5889_16[]; + static Coding tokenCoding5889_17[]; + static Coding tokenCoding5889_18[]; + static Coding tokenCoding5889_19[]; + void TokenFunc5889(x64Operand &operand, int tokenPos); + static Coding tokenCoding5890_16[]; + static Coding tokenCoding5890_17[]; + static Coding tokenCoding5890_18[]; + static Coding tokenCoding5890_19[]; + void TokenFunc5890(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5891[]; + static Coding tokenCoding5892_16[]; + static Coding tokenCoding5892_17[]; + static Coding tokenCoding5892_18[]; + static Coding tokenCoding5892_19[]; + void TokenFunc5892(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5893[]; + static Coding tokenCoding5894_16[]; + static Coding tokenCoding5894_17[]; + static Coding tokenCoding5894_18[]; + static Coding tokenCoding5894_19[]; + void TokenFunc5894(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5895[]; + static Coding tokenCoding5896_16[]; + static Coding tokenCoding5896_17[]; + static Coding tokenCoding5896_18[]; + static Coding tokenCoding5896_19[]; + void TokenFunc5896(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5897[]; + void TokenFunc5898(x64Operand &operand, int tokenPos); + void TokenFunc5900(x64Operand &operand, int tokenPos); + static Coding tokenCoding5902_16[]; + static Coding tokenCoding5902_17[]; + static Coding tokenCoding5902_18[]; + static Coding tokenCoding5902_19[]; + void TokenFunc5902(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5904[]; + static Coding tokenCoding5905_16[]; + static Coding tokenCoding5905_17[]; + static Coding tokenCoding5905_18[]; + static Coding tokenCoding5905_19[]; + void TokenFunc5905(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5907[]; + static Coding tokenCoding5908_16[]; + static Coding tokenCoding5908_17[]; + static Coding tokenCoding5908_18[]; + static Coding tokenCoding5908_19[]; + void TokenFunc5908(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5911[]; + void TokenFunc5912(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5949[]; + static x64Token tokenBranches5950[]; + static x64Token tokenBranches5951[]; + static x64Token tokenBranches5952[]; + static x64Token tokenBranches5953[]; + static x64Token tokenBranches5954[]; + static x64Token tokenBranches5955[]; + static x64Token tokenBranches5956[]; + static x64Token tokenBranches5957[]; + static x64Token tokenBranches5958[]; + static x64Token tokenBranches5959[]; + static x64Token tokenBranches5960[]; + static x64Token tokenBranches5961[]; + void TokenFunc5962(x64Operand &operand, int tokenPos); + void TokenFunc5965(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5965[]; + static x64Token tokenBranches5966[]; + static x64Token tokenBranches5967[]; + static x64Token tokenBranches5968[]; + static x64Token tokenBranches5969[]; + static x64Token tokenBranches5970[]; + static x64Token tokenBranches5971[]; + static x64Token tokenBranches5972[]; + static x64Token tokenBranches5973[]; + static x64Token tokenBranches5974[]; + void TokenFunc5975(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5980[]; + static x64Token tokenBranches5981[]; + static x64Token tokenBranches5982[]; + static x64Token tokenBranches5983[]; + static x64Token tokenBranches5984[]; + static x64Token tokenBranches5985[]; + static x64Token tokenBranches5986[]; + static x64Token tokenBranches5987[]; + void TokenFunc5988(x64Operand &operand, int tokenPos); + static x64Token tokenBranches5993[]; + static x64Token tokenBranches5994[]; + static x64Token tokenBranches5995[]; + static x64Token tokenBranches5996[]; + static x64Token tokenBranches5997[]; + static x64Token tokenBranches5998[]; + static x64Token tokenBranches5999[]; + static x64Token tokenBranches6000[]; + void TokenFunc6001(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6004[]; + static x64Token tokenBranches6005[]; + static x64Token tokenBranches6006[]; + static x64Token tokenBranches6007[]; + static x64Token tokenBranches6008[]; + static x64Token tokenBranches6009[]; + void TokenFunc6010(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6015[]; + static x64Token tokenBranches6016[]; + static x64Token tokenBranches6017[]; + static x64Token tokenBranches6018[]; + static x64Token tokenBranches6019[]; + static x64Token tokenBranches6020[]; + static x64Token tokenBranches6021[]; + static x64Token tokenBranches6022[]; + void TokenFunc6023(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6024[]; + static x64Token tokenBranches6025[]; + static x64Token tokenBranches6026[]; + static x64Token tokenBranches6027[]; + static x64Token tokenBranches6028[]; + static x64Token tokenBranches6029[]; + static x64Token tokenBranches6030[]; + static x64Token tokenBranches6031[]; + static x64Token tokenBranches6032[]; + static x64Token tokenBranches6033[]; + static x64Token tokenBranches6034[]; + static x64Token tokenBranches6035[]; + void TokenFunc6036(x64Operand &operand, int tokenPos); + void TokenFunc6039(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6039[]; + static x64Token tokenBranches6040[]; + static x64Token tokenBranches6041[]; + static x64Token tokenBranches6042[]; + static x64Token tokenBranches6043[]; + static x64Token tokenBranches6044[]; + static x64Token tokenBranches6045[]; + static x64Token tokenBranches6046[]; + static x64Token tokenBranches6047[]; + static x64Token tokenBranches6048[]; + void TokenFunc6049(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6054[]; + static x64Token tokenBranches6055[]; + static x64Token tokenBranches6056[]; + static x64Token tokenBranches6057[]; + static x64Token tokenBranches6058[]; + static x64Token tokenBranches6059[]; + static x64Token tokenBranches6060[]; + static x64Token tokenBranches6061[]; + void TokenFunc6062(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6067[]; + static x64Token tokenBranches6068[]; + static x64Token tokenBranches6069[]; + static x64Token tokenBranches6070[]; + static x64Token tokenBranches6071[]; + static x64Token tokenBranches6072[]; + static x64Token tokenBranches6073[]; + static x64Token tokenBranches6074[]; + void TokenFunc6075(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6078[]; + static x64Token tokenBranches6079[]; + static x64Token tokenBranches6080[]; + static x64Token tokenBranches6081[]; + static x64Token tokenBranches6082[]; + static x64Token tokenBranches6083[]; + void TokenFunc6084(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6089[]; + static x64Token tokenBranches6090[]; + static x64Token tokenBranches6091[]; + static x64Token tokenBranches6092[]; + static x64Token tokenBranches6093[]; + static x64Token tokenBranches6094[]; + void TokenFunc6095(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6096[]; + static x64Token tokenBranches6097[]; + static x64Token tokenBranches6098[]; + static x64Token tokenBranches6099[]; + static x64Token tokenBranches6100[]; + static x64Token tokenBranches6101[]; + static x64Token tokenBranches6102[]; + static x64Token tokenBranches6103[]; + static x64Token tokenBranches6104[]; + static x64Token tokenBranches6105[]; + static x64Token tokenBranches6106[]; + static x64Token tokenBranches6107[]; + void TokenFunc6108(x64Operand &operand, int tokenPos); + void TokenFunc6111(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6111[]; + static x64Token tokenBranches6112[]; + static x64Token tokenBranches6113[]; + static x64Token tokenBranches6114[]; + static x64Token tokenBranches6115[]; + static x64Token tokenBranches6116[]; + static x64Token tokenBranches6117[]; + static x64Token tokenBranches6118[]; + static x64Token tokenBranches6119[]; + static x64Token tokenBranches6120[]; + void TokenFunc6121(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6126[]; + static x64Token tokenBranches6127[]; + static x64Token tokenBranches6128[]; + static x64Token tokenBranches6129[]; + static x64Token tokenBranches6130[]; + static x64Token tokenBranches6131[]; + static x64Token tokenBranches6132[]; + static x64Token tokenBranches6133[]; + void TokenFunc6134(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6139[]; + static x64Token tokenBranches6140[]; + static x64Token tokenBranches6141[]; + static x64Token tokenBranches6142[]; + static x64Token tokenBranches6143[]; + static x64Token tokenBranches6144[]; + static x64Token tokenBranches6145[]; + static x64Token tokenBranches6146[]; + void TokenFunc6147(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6150[]; + static x64Token tokenBranches6151[]; + static x64Token tokenBranches6152[]; + static x64Token tokenBranches6153[]; + static x64Token tokenBranches6154[]; + static x64Token tokenBranches6155[]; + void TokenFunc6156(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6161[]; + static x64Token tokenBranches6162[]; + static x64Token tokenBranches6163[]; + static x64Token tokenBranches6164[]; + static x64Token tokenBranches6165[]; + static x64Token tokenBranches6166[]; + void TokenFunc6167(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6168[]; + static x64Token tokenBranches6169[]; + static x64Token tokenBranches6170[]; + static x64Token tokenBranches6171[]; + static x64Token tokenBranches6172[]; + static x64Token tokenBranches6173[]; + static x64Token tokenBranches6174[]; + static x64Token tokenBranches6175[]; + static x64Token tokenBranches6176[]; + static x64Token tokenBranches6177[]; + static x64Token tokenBranches6178[]; + static x64Token tokenBranches6179[]; + void TokenFunc6180(x64Operand &operand, int tokenPos); + void TokenFunc6183(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6183[]; + static x64Token tokenBranches6184[]; + static x64Token tokenBranches6185[]; + static x64Token tokenBranches6186[]; + static x64Token tokenBranches6187[]; + static x64Token tokenBranches6188[]; + static x64Token tokenBranches6189[]; + static x64Token tokenBranches6190[]; + static x64Token tokenBranches6191[]; + static x64Token tokenBranches6192[]; + void TokenFunc6193(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6196[]; + static x64Token tokenBranches6197[]; + static x64Token tokenBranches6198[]; + static x64Token tokenBranches6199[]; + static x64Token tokenBranches6200[]; + static x64Token tokenBranches6201[]; + void TokenFunc6202(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6207[]; + static x64Token tokenBranches6208[]; + static x64Token tokenBranches6209[]; + static x64Token tokenBranches6210[]; + static x64Token tokenBranches6211[]; + static x64Token tokenBranches6212[]; + void TokenFunc6213(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6217[]; + void TokenFunc6218(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6219[]; + static x64Token tokenBranches6220[]; + static x64Token tokenBranches6221[]; + static x64Token tokenBranches6222[]; + static Coding tokenCoding6223_16[]; + static Coding tokenCoding6223_17[]; + static Coding tokenCoding6223_18[]; + static Coding tokenCoding6223_19[]; + void TokenFunc6223(x64Operand &operand, int tokenPos); + static Coding tokenCoding6227_16[]; + static Coding tokenCoding6227_17[]; + static Coding tokenCoding6227_23[]; + static Coding tokenCoding6227_18[]; + static Coding tokenCoding6227_19[]; + void TokenFunc6227(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6228[]; + static x64Token tokenBranches6229[]; + static x64Token tokenBranches6230[]; + static Coding tokenCoding6231_16[]; + static Coding tokenCoding6231_17[]; + static Coding tokenCoding6231_18[]; + static Coding tokenCoding6231_19[]; + void TokenFunc6231(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6232[]; + static x64Token tokenBranches6233[]; + static x64Token tokenBranches6234[]; + static Coding tokenCoding6235_16[]; + static Coding tokenCoding6235_17[]; + static Coding tokenCoding6235_18[]; + static Coding tokenCoding6235_19[]; + void TokenFunc6235(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6236[]; + static x64Token tokenBranches6237[]; + static x64Token tokenBranches6238[]; + static Coding tokenCoding6239_16[]; + static Coding tokenCoding6239_17[]; + static Coding tokenCoding6239_18[]; + static Coding tokenCoding6239_19[]; + void TokenFunc6239(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6240[]; + static Coding tokenCoding6241_16[]; + static Coding tokenCoding6241_17[]; + static Coding tokenCoding6241_18[]; + static Coding tokenCoding6241_19[]; + void TokenFunc6241(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6242[]; + static Coding tokenCoding6243_16[]; + static Coding tokenCoding6243_17[]; + static Coding tokenCoding6243_18[]; + static Coding tokenCoding6243_19[]; + void TokenFunc6243(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6245[]; + void TokenFunc6246(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6253[]; + static x64Token tokenBranches6254[]; + void TokenFunc6255(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6255[]; + static x64Token tokenBranches6256[]; + static x64Token tokenBranches6257[]; + void TokenFunc6258(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6259[]; + void TokenFunc6260(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6260[]; + static x64Token tokenBranches6261[]; + static Coding tokenCoding6262_16[]; + static Coding tokenCoding6262_17[]; + static Coding tokenCoding6262_18[]; + static Coding tokenCoding6262_19[]; + void TokenFunc6262(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6272[]; + static x64Token tokenBranches6273[]; + static x64Token tokenBranches6274[]; + void TokenFunc6275(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6276[]; + static x64Token tokenBranches6277[]; + static x64Token tokenBranches6278[]; + void TokenFunc6279(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6280[]; + static x64Token tokenBranches6281[]; + static x64Token tokenBranches6282[]; + void TokenFunc6283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6284[]; + static x64Token tokenBranches6285[]; + static x64Token tokenBranches6286[]; + void TokenFunc6287(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6288[]; + static x64Token tokenBranches6289[]; + static x64Token tokenBranches6290[]; + void TokenFunc6291(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6292[]; + static x64Token tokenBranches6293[]; + static x64Token tokenBranches6294[]; + void TokenFunc6295(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6296[]; + static x64Token tokenBranches6297[]; + static x64Token tokenBranches6298[]; + void TokenFunc6299(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6300[]; + static x64Token tokenBranches6301[]; + static x64Token tokenBranches6302[]; + void TokenFunc6303(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6304[]; + static x64Token tokenBranches6305[]; + static x64Token tokenBranches6306[]; + void TokenFunc6307(x64Operand &operand, int tokenPos); + void TokenFunc6308(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6309[]; + static Coding tokenCoding6310_16[]; + static Coding tokenCoding6310_17[]; + static Coding tokenCoding6310_19[]; + void TokenFunc6310(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6311[]; + static Coding tokenCoding6312_16[]; + static Coding tokenCoding6312_17[]; + static Coding tokenCoding6312_19[]; + void TokenFunc6312(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6313[]; + static x64Token tokenBranches6314[]; + static x64Token tokenBranches6315[]; + void TokenFunc6316(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6317[]; + static x64Token tokenBranches6318[]; + static x64Token tokenBranches6319[]; + void TokenFunc6320(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6321[]; + void TokenFunc6322(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6323[]; + static Coding tokenCoding6324_16[]; + static Coding tokenCoding6324_17[]; + static Coding tokenCoding6324_19[]; + void TokenFunc6324(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6325[]; + static Coding tokenCoding6326_16[]; + static Coding tokenCoding6326_17[]; + static Coding tokenCoding6326_19[]; + void TokenFunc6326(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6336[]; + static Coding tokenCoding6337_18[]; + static Coding tokenCoding6337_19[]; + void TokenFunc6337(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6338[]; + static Coding tokenCoding6339_18[]; + static Coding tokenCoding6339_19[]; + void TokenFunc6339(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6345[]; + static x64Token tokenBranches6346[]; + static Coding tokenCoding6347_16[]; + static Coding tokenCoding6347_17[]; + static Coding tokenCoding6347_18[]; + static Coding tokenCoding6347_19[]; + void TokenFunc6347(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6348[]; + static Coding tokenCoding6349_16[]; + static Coding tokenCoding6349_17[]; + static Coding tokenCoding6349_18[]; + static Coding tokenCoding6349_19[]; + void TokenFunc6349(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6350[]; + static Coding tokenCoding6351_16[]; + static Coding tokenCoding6351_17[]; + static Coding tokenCoding6351_18[]; + static Coding tokenCoding6351_19[]; + void TokenFunc6351(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6357[]; + static x64Token tokenBranches6358[]; + static Coding tokenCoding6359_16[]; + static Coding tokenCoding6359_17[]; + static Coding tokenCoding6359_18[]; + static Coding tokenCoding6359_19[]; + void TokenFunc6359(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6360[]; + static Coding tokenCoding6361_16[]; + static Coding tokenCoding6361_17[]; + static Coding tokenCoding6361_18[]; + static Coding tokenCoding6361_19[]; + void TokenFunc6361(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6364[]; + static Coding tokenCoding6365_18[]; + static Coding tokenCoding6365_19[]; + void TokenFunc6365(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6366[]; + static Coding tokenCoding6367_16[]; + static Coding tokenCoding6367_17[]; + static Coding tokenCoding6367_18[]; + static Coding tokenCoding6367_19[]; + void TokenFunc6367(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6368[]; + static Coding tokenCoding6369_16[]; + static Coding tokenCoding6369_17[]; + static Coding tokenCoding6369_18[]; + static Coding tokenCoding6369_19[]; + void TokenFunc6369(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6370[]; + static Coding tokenCoding6371_16[]; + static Coding tokenCoding6371_17[]; + static Coding tokenCoding6371_18[]; + static Coding tokenCoding6371_19[]; + void TokenFunc6371(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6373[]; + static x64Token tokenBranches6374[]; + static Coding tokenCoding6375_16[]; + static Coding tokenCoding6375_17[]; + static Coding tokenCoding6375_18[]; + static Coding tokenCoding6375_19[]; + void TokenFunc6375(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6376[]; + static Coding tokenCoding6377_16[]; + static Coding tokenCoding6377_17[]; + static Coding tokenCoding6377_18[]; + static Coding tokenCoding6377_19[]; + void TokenFunc6377(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6387[]; + static Coding tokenCoding6388_16[]; + static Coding tokenCoding6388_17[]; + static Coding tokenCoding6388_18[]; + static Coding tokenCoding6388_19[]; + void TokenFunc6388(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6394[]; + static Coding tokenCoding6395_16[]; + static Coding tokenCoding6395_17[]; + static Coding tokenCoding6395_18[]; + static Coding tokenCoding6395_19[]; + void TokenFunc6395(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6396[]; + static Coding tokenCoding6397_16[]; + static Coding tokenCoding6397_17[]; + static Coding tokenCoding6397_18[]; + static Coding tokenCoding6397_19[]; + void TokenFunc6397(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6403[]; + static Coding tokenCoding6404_18[]; + static Coding tokenCoding6404_19[]; + void TokenFunc6404(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6405[]; + static Coding tokenCoding6406_16[]; + static Coding tokenCoding6406_17[]; + static Coding tokenCoding6406_18[]; + static Coding tokenCoding6406_19[]; + void TokenFunc6406(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6407[]; + static Coding tokenCoding6408_16[]; + static Coding tokenCoding6408_17[]; + static Coding tokenCoding6408_18[]; + static Coding tokenCoding6408_19[]; + void TokenFunc6408(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6409[]; + static x64Token tokenBranches6410[]; + static Coding tokenCoding6411_16[]; + static Coding tokenCoding6411_17[]; + static Coding tokenCoding6411_18[]; + static Coding tokenCoding6411_19[]; + void TokenFunc6411(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6412[]; + static x64Token tokenBranches6413[]; + static Coding tokenCoding6414_16[]; + static Coding tokenCoding6414_17[]; + static Coding tokenCoding6414_18[]; + static Coding tokenCoding6414_19[]; + void TokenFunc6414(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6415[]; + static Coding tokenCoding6416_16[]; + static Coding tokenCoding6416_17[]; + static Coding tokenCoding6416_18[]; + static Coding tokenCoding6416_19[]; + void TokenFunc6416(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6417[]; + static Coding tokenCoding6418_16[]; + static Coding tokenCoding6418_17[]; + static Coding tokenCoding6418_18[]; + static Coding tokenCoding6418_19[]; + void TokenFunc6418(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6419[]; + static Coding tokenCoding6420_18[]; + static Coding tokenCoding6420_19[]; + void TokenFunc6420(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6421[]; + static Coding tokenCoding6422_16[]; + static Coding tokenCoding6422_17[]; + static Coding tokenCoding6422_18[]; + static Coding tokenCoding6422_19[]; + void TokenFunc6422(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6423[]; + static Coding tokenCoding6424_16[]; + static Coding tokenCoding6424_17[]; + static Coding tokenCoding6424_18[]; + static Coding tokenCoding6424_19[]; + void TokenFunc6424(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6425[]; + static Coding tokenCoding6426_16[]; + static Coding tokenCoding6426_17[]; + static Coding tokenCoding6426_18[]; + static Coding tokenCoding6426_19[]; + void TokenFunc6426(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6427[]; + static x64Token tokenBranches6428[]; + static Coding tokenCoding6429_16[]; + static Coding tokenCoding6429_17[]; + static Coding tokenCoding6429_18[]; + static Coding tokenCoding6429_19[]; + void TokenFunc6429(x64Operand &operand, int tokenPos); + void TokenFunc6430(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6431[]; + static x64Token tokenBranches6432[]; + static Coding tokenCoding6433_16[]; + static Coding tokenCoding6433_17[]; + static Coding tokenCoding6433_18[]; + static Coding tokenCoding6433_19[]; + void TokenFunc6433(x64Operand &operand, int tokenPos); + void TokenFunc6434(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6441[]; + static x64Token tokenBranches6442[]; + static x64Token tokenBranches6443[]; + void TokenFunc6444(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6445[]; + static x64Token tokenBranches6446[]; + static x64Token tokenBranches6447[]; + void TokenFunc6448(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6454[]; + static x64Token tokenBranches6455[]; + static x64Token tokenBranches6456[]; + void TokenFunc6457(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6458[]; + static x64Token tokenBranches6459[]; + static x64Token tokenBranches6460[]; + void TokenFunc6461(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6462[]; + static Coding tokenCoding6463_16[]; + static Coding tokenCoding6463_17[]; + static Coding tokenCoding6463_18[]; + static Coding tokenCoding6463_19[]; + void TokenFunc6463(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6464[]; + static Coding tokenCoding6465_16[]; + static Coding tokenCoding6465_17[]; + static Coding tokenCoding6465_18[]; + static Coding tokenCoding6465_19[]; + void TokenFunc6465(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6472[]; + void TokenFunc6473(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6473[]; + static x64Token tokenBranches6474[]; + static x64Token tokenBranches6475[]; + void TokenFunc6476(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6479[]; + void TokenFunc6480(x64Operand &operand, int tokenPos); + void TokenFunc6481(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6481[]; + static x64Token tokenBranches6482[]; + static x64Token tokenBranches6483[]; + void TokenFunc6484(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6487[]; + void TokenFunc6488(x64Operand &operand, int tokenPos); + void TokenFunc6489(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6489[]; + static x64Token tokenBranches6490[]; + static x64Token tokenBranches6491[]; + void TokenFunc6492(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6495[]; + void TokenFunc6496(x64Operand &operand, int tokenPos); + static Coding tokenCoding6500_16[]; + static Coding tokenCoding6500_17[]; + static Coding tokenCoding6500_18[]; + static Coding tokenCoding6500_19[]; + void TokenFunc6500(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6500[]; + static x64Token tokenBranches6501[]; + static x64Token tokenBranches6502[]; + static Coding tokenCoding6503_16[]; + static Coding tokenCoding6503_17[]; + static Coding tokenCoding6503_18[]; + static Coding tokenCoding6503_19[]; + void TokenFunc6503(x64Operand &operand, int tokenPos); + static Coding tokenCoding6509_16[]; + static Coding tokenCoding6509_17[]; + static Coding tokenCoding6509_18[]; + static Coding tokenCoding6509_19[]; + void TokenFunc6509(x64Operand &operand, int tokenPos); + static Coding tokenCoding6517_16[]; + static Coding tokenCoding6517_17[]; + static Coding tokenCoding6517_18[]; + static Coding tokenCoding6517_19[]; + void TokenFunc6517(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6517[]; + static x64Token tokenBranches6518[]; + static x64Token tokenBranches6519[]; + static Coding tokenCoding6520_16[]; + static Coding tokenCoding6520_17[]; + static Coding tokenCoding6520_18[]; + static Coding tokenCoding6520_19[]; + void TokenFunc6520(x64Operand &operand, int tokenPos); + static Coding tokenCoding6526_16[]; + static Coding tokenCoding6526_17[]; + static Coding tokenCoding6526_18[]; + static Coding tokenCoding6526_19[]; + void TokenFunc6526(x64Operand &operand, int tokenPos); + static Coding tokenCoding6534_16[]; + static Coding tokenCoding6534_17[]; + static Coding tokenCoding6534_18[]; + static Coding tokenCoding6534_19[]; + void TokenFunc6534(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6534[]; + static x64Token tokenBranches6535[]; + static x64Token tokenBranches6536[]; + static Coding tokenCoding6537_16[]; + static Coding tokenCoding6537_17[]; + static Coding tokenCoding6537_18[]; + static Coding tokenCoding6537_19[]; + void TokenFunc6537(x64Operand &operand, int tokenPos); + static Coding tokenCoding6543_16[]; + static Coding tokenCoding6543_17[]; + static Coding tokenCoding6543_18[]; + static Coding tokenCoding6543_19[]; + void TokenFunc6543(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6548[]; + static Coding tokenCoding6549_16[]; + static Coding tokenCoding6549_17[]; + static Coding tokenCoding6549_18[]; + static Coding tokenCoding6549_19[]; + void TokenFunc6549(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6550[]; + static Coding tokenCoding6551_16[]; + static Coding tokenCoding6551_17[]; + static Coding tokenCoding6551_18[]; + static Coding tokenCoding6551_19[]; + void TokenFunc6551(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6552[]; + static Coding tokenCoding6553_16[]; + static Coding tokenCoding6553_17[]; + static Coding tokenCoding6553_18[]; + static Coding tokenCoding6553_19[]; + void TokenFunc6553(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6554[]; + static Coding tokenCoding6555_16[]; + static Coding tokenCoding6555_17[]; + static Coding tokenCoding6555_18[]; + static Coding tokenCoding6555_19[]; + void TokenFunc6555(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6556[]; + static x64Token tokenBranches6557[]; + static x64Token tokenBranches6558[]; + static x64Token tokenBranches6559[]; + void TokenFunc6560(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6561[]; + static x64Token tokenBranches6562[]; + static x64Token tokenBranches6563[]; + void TokenFunc6564(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6565[]; + static x64Token tokenBranches6566[]; + static x64Token tokenBranches6567[]; + void TokenFunc6568(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6569[]; + static x64Token tokenBranches6570[]; + static x64Token tokenBranches6571[]; + void TokenFunc6572(x64Operand &operand, int tokenPos); + void TokenFunc6575(x64Operand &operand, int tokenPos); + void TokenFunc6578(x64Operand &operand, int tokenPos); + void TokenFunc6581(x64Operand &operand, int tokenPos); + void TokenFunc6584(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6585[]; + static x64Token tokenBranches6586[]; + static x64Token tokenBranches6587[]; + static x64Token tokenBranches6588[]; + static x64Token tokenBranches6589[]; + static x64Token tokenBranches6590[]; + static x64Token tokenBranches6591[]; + static x64Token tokenBranches6592[]; + void TokenFunc6593(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6595[]; + void TokenFunc6596(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6596[]; + static x64Token tokenBranches6597[]; + static x64Token tokenBranches6598[]; + static x64Token tokenBranches6599[]; + static x64Token tokenBranches6600[]; + void TokenFunc6601(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6606[]; + static x64Token tokenBranches6607[]; + static x64Token tokenBranches6608[]; + void TokenFunc6609(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6614[]; + static x64Token tokenBranches6615[]; + static x64Token tokenBranches6616[]; + void TokenFunc6617(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6620[]; + static x64Token tokenBranches6621[]; + static x64Token tokenBranches6622[]; + void TokenFunc6623(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6628[]; + static x64Token tokenBranches6629[]; + static x64Token tokenBranches6630[]; + void TokenFunc6631(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6632[]; + static x64Token tokenBranches6633[]; + static x64Token tokenBranches6634[]; + static x64Token tokenBranches6635[]; + static x64Token tokenBranches6636[]; + static x64Token tokenBranches6637[]; + static x64Token tokenBranches6638[]; + void TokenFunc6639(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6641[]; + void TokenFunc6642(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6642[]; + static x64Token tokenBranches6643[]; + static x64Token tokenBranches6644[]; + static x64Token tokenBranches6645[]; + static x64Token tokenBranches6646[]; + void TokenFunc6647(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6652[]; + static x64Token tokenBranches6653[]; + static x64Token tokenBranches6654[]; + void TokenFunc6655(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6660[]; + static x64Token tokenBranches6661[]; + static x64Token tokenBranches6662[]; + void TokenFunc6663(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6666[]; + static x64Token tokenBranches6667[]; + static x64Token tokenBranches6668[]; + void TokenFunc6669(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6674[]; + static x64Token tokenBranches6675[]; + static x64Token tokenBranches6676[]; + void TokenFunc6677(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6678[]; + static x64Token tokenBranches6679[]; + static x64Token tokenBranches6680[]; + static x64Token tokenBranches6681[]; + static x64Token tokenBranches6682[]; + static x64Token tokenBranches6683[]; + static x64Token tokenBranches6684[]; + void TokenFunc6685(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6687[]; + void TokenFunc6688(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6688[]; + static x64Token tokenBranches6689[]; + static x64Token tokenBranches6690[]; + static x64Token tokenBranches6691[]; + static x64Token tokenBranches6692[]; + void TokenFunc6693(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6698[]; + static x64Token tokenBranches6699[]; + static x64Token tokenBranches6700[]; + void TokenFunc6701(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6706[]; + static x64Token tokenBranches6707[]; + static x64Token tokenBranches6708[]; + void TokenFunc6709(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6712[]; + static x64Token tokenBranches6713[]; + static x64Token tokenBranches6714[]; + void TokenFunc6715(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6720[]; + static x64Token tokenBranches6721[]; + static x64Token tokenBranches6722[]; + void TokenFunc6723(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6728[]; + static x64Token tokenBranches6729[]; + void TokenFunc6730(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6735[]; + static Coding tokenCoding6736_16[]; + static Coding tokenCoding6736_17[]; + static Coding tokenCoding6736_18[]; + static Coding tokenCoding6736_19[]; + void TokenFunc6736(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6739[]; + void TokenFunc6740(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6747[]; + void TokenFunc6748(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6749[]; + void TokenFunc6750(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6756[]; + static x64Token tokenBranches6757[]; + void TokenFunc6758(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6758[]; + static x64Token tokenBranches6759[]; + static x64Token tokenBranches6760[]; + void TokenFunc6761(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6765[]; + void TokenFunc6766(x64Operand &operand, int tokenPos); + void TokenFunc6768(x64Operand &operand, int tokenPos); + void TokenFunc6770(x64Operand &operand, int tokenPos); + static Coding tokenCoding6772_16[]; + static Coding tokenCoding6772_17[]; + static Coding tokenCoding6772_18[]; + static Coding tokenCoding6772_19[]; + void TokenFunc6772(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6774[]; + static Coding tokenCoding6775_16[]; + static Coding tokenCoding6775_17[]; + static Coding tokenCoding6775_18[]; + static Coding tokenCoding6775_19[]; + void TokenFunc6775(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6777[]; + static Coding tokenCoding6778_16[]; + static Coding tokenCoding6778_17[]; + static Coding tokenCoding6778_18[]; + static Coding tokenCoding6778_19[]; + void TokenFunc6778(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6779[]; + void TokenFunc6780(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6781[]; + void TokenFunc6782(x64Operand &operand, int tokenPos); + void TokenFunc6784(x64Operand &operand, int tokenPos); + void TokenFunc6785(x64Operand &operand, int tokenPos); + void TokenFunc6786(x64Operand &operand, int tokenPos); + static Coding tokenCoding6787_16[]; + static Coding tokenCoding6787_17[]; + static Coding tokenCoding6787_18[]; + static Coding tokenCoding6787_19[]; + void TokenFunc6787(x64Operand &operand, int tokenPos); + static Coding tokenCoding6788_16[]; + static Coding tokenCoding6788_17[]; + static Coding tokenCoding6788_18[]; + static Coding tokenCoding6788_19[]; + void TokenFunc6788(x64Operand &operand, int tokenPos); + static Coding tokenCoding6789_16[]; + static Coding tokenCoding6789_17[]; + static Coding tokenCoding6789_18[]; + static Coding tokenCoding6789_19[]; + void TokenFunc6789(x64Operand &operand, int tokenPos); + static Coding tokenCoding6790_16[]; + static Coding tokenCoding6790_17[]; + static Coding tokenCoding6790_18[]; + static Coding tokenCoding6790_19[]; + void TokenFunc6790(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6791[]; + static Coding tokenCoding6792_16[]; + static Coding tokenCoding6792_17[]; + static Coding tokenCoding6792_18[]; + static Coding tokenCoding6792_19[]; + void TokenFunc6792(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6793[]; + static Coding tokenCoding6794_16[]; + static Coding tokenCoding6794_17[]; + static Coding tokenCoding6794_18[]; + static Coding tokenCoding6794_19[]; + void TokenFunc6794(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6795[]; + static Coding tokenCoding6796_16[]; + static Coding tokenCoding6796_17[]; + static Coding tokenCoding6796_18[]; + static Coding tokenCoding6796_19[]; + void TokenFunc6796(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6829[]; + static Coding tokenCoding6830_16[]; + static Coding tokenCoding6830_17[]; + static Coding tokenCoding6830_18[]; + static Coding tokenCoding6830_19[]; + void TokenFunc6830(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6831[]; + static x64Token tokenBranches6832[]; + static x64Token tokenBranches6833[]; + static x64Token tokenBranches6834[]; + static x64Token tokenBranches6835[]; + static x64Token tokenBranches6836[]; + void TokenFunc6837(x64Operand &operand, int tokenPos); + void TokenFunc6840(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6840[]; + static x64Token tokenBranches6841[]; + static x64Token tokenBranches6842[]; + void TokenFunc6843(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6848[]; + void TokenFunc6849(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6854[]; + void TokenFunc6855(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6858[]; + void TokenFunc6859(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6864[]; + void TokenFunc6865(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6866[]; + static x64Token tokenBranches6867[]; + static x64Token tokenBranches6868[]; + static x64Token tokenBranches6869[]; + static x64Token tokenBranches6870[]; + void TokenFunc6871(x64Operand &operand, int tokenPos); + void TokenFunc6874(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6874[]; + static x64Token tokenBranches6875[]; + static x64Token tokenBranches6876[]; + void TokenFunc6877(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6882[]; + void TokenFunc6883(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6888[]; + void TokenFunc6889(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6892[]; + void TokenFunc6893(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6898[]; + void TokenFunc6899(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6900[]; + static x64Token tokenBranches6901[]; + static x64Token tokenBranches6902[]; + static x64Token tokenBranches6903[]; + static x64Token tokenBranches6904[]; + void TokenFunc6905(x64Operand &operand, int tokenPos); + void TokenFunc6908(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6908[]; + static x64Token tokenBranches6909[]; + static x64Token tokenBranches6910[]; + void TokenFunc6911(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6916[]; + void TokenFunc6917(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6922[]; + void TokenFunc6923(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6926[]; + void TokenFunc6927(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6932[]; + void TokenFunc6933(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6934[]; + static x64Token tokenBranches6935[]; + static x64Token tokenBranches6936[]; + static x64Token tokenBranches6937[]; + static x64Token tokenBranches6938[]; + void TokenFunc6939(x64Operand &operand, int tokenPos); + void TokenFunc6942(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6942[]; + static x64Token tokenBranches6943[]; + static x64Token tokenBranches6944[]; + void TokenFunc6945(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6948[]; + void TokenFunc6949(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6954[]; + void TokenFunc6955(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6959[]; + void TokenFunc6960(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6961[]; + void TokenFunc6962(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6963[]; + void TokenFunc6964(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6965[]; + void TokenFunc6966(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6967[]; + void TokenFunc6968(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6969[]; + void TokenFunc6970(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6973[]; + static Coding tokenCoding6974_16[]; + static Coding tokenCoding6974_17[]; + static Coding tokenCoding6974_18[]; + static Coding tokenCoding6974_19[]; + void TokenFunc6974(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6975[]; + void TokenFunc6976(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6976[]; + static x64Token tokenBranches6977[]; + static Coding tokenCoding6978_16[]; + static Coding tokenCoding6978_17[]; + static Coding tokenCoding6978_18[]; + static Coding tokenCoding6978_19[]; + void TokenFunc6978(x64Operand &operand, int tokenPos); + void TokenFunc6979(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6979[]; + static x64Token tokenBranches6980[]; + static Coding tokenCoding6981_16[]; + static Coding tokenCoding6981_17[]; + static Coding tokenCoding6981_18[]; + static Coding tokenCoding6981_19[]; + void TokenFunc6981(x64Operand &operand, int tokenPos); + void TokenFunc6982(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6982[]; + static x64Token tokenBranches6983[]; + static Coding tokenCoding6984_16[]; + static Coding tokenCoding6984_17[]; + static Coding tokenCoding6984_18[]; + static Coding tokenCoding6984_19[]; + void TokenFunc6984(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6985[]; + static x64Token tokenBranches6986[]; + static x64Token tokenBranches6987[]; + static x64Token tokenBranches6988[]; + void TokenFunc6989(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6989[]; + void TokenFunc6990(x64Operand &operand, int tokenPos); + void TokenFunc6995(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6995[]; + static x64Token tokenBranches6996[]; + void TokenFunc6997(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6997[]; + void TokenFunc6998(x64Operand &operand, int tokenPos); + void TokenFunc7003(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7003[]; + void TokenFunc7004(x64Operand &operand, int tokenPos); + void TokenFunc7011(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7011[]; + void TokenFunc7012(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7013[]; + static x64Token tokenBranches7014[]; + static x64Token tokenBranches7015[]; + static x64Token tokenBranches7016[]; + void TokenFunc7017(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7017[]; + void TokenFunc7018(x64Operand &operand, int tokenPos); + void TokenFunc7023(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7023[]; + static x64Token tokenBranches7024[]; + void TokenFunc7025(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7025[]; + void TokenFunc7026(x64Operand &operand, int tokenPos); + void TokenFunc7031(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7031[]; + void TokenFunc7032(x64Operand &operand, int tokenPos); + void TokenFunc7039(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7039[]; + void TokenFunc7040(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7041[]; + static x64Token tokenBranches7042[]; + static x64Token tokenBranches7043[]; + static x64Token tokenBranches7044[]; + void TokenFunc7045(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7045[]; + void TokenFunc7046(x64Operand &operand, int tokenPos); + void TokenFunc7051(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7051[]; + static x64Token tokenBranches7052[]; + void TokenFunc7053(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7053[]; + void TokenFunc7054(x64Operand &operand, int tokenPos); + void TokenFunc7059(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7059[]; + void TokenFunc7060(x64Operand &operand, int tokenPos); + void TokenFunc7067(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7067[]; + void TokenFunc7068(x64Operand &operand, int tokenPos); + void TokenFunc7069(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7069[]; + static x64Token tokenBranches7070[]; + static x64Token tokenBranches7071[]; + void TokenFunc7072(x64Operand &operand, int tokenPos); + void TokenFunc7073(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7073[]; + static x64Token tokenBranches7074[]; + static x64Token tokenBranches7075[]; + void TokenFunc7076(x64Operand &operand, int tokenPos); + void TokenFunc7077(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7077[]; + static x64Token tokenBranches7078[]; + static x64Token tokenBranches7079[]; + void TokenFunc7080(x64Operand &operand, int tokenPos); + void TokenFunc7081(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7081[]; + static x64Token tokenBranches7082[]; + static x64Token tokenBranches7083[]; + void TokenFunc7084(x64Operand &operand, int tokenPos); + void TokenFunc7085(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7085[]; + static x64Token tokenBranches7086[]; + static x64Token tokenBranches7087[]; + void TokenFunc7088(x64Operand &operand, int tokenPos); + static Coding tokenCoding7092_16[]; + static Coding tokenCoding7092_17[]; + static Coding tokenCoding7092_18[]; + static Coding tokenCoding7092_19[]; + void TokenFunc7092(x64Operand &operand, int tokenPos); + static Coding tokenCoding7096_16[]; + static Coding tokenCoding7096_17[]; + static Coding tokenCoding7096_23[]; + static Coding tokenCoding7096_18[]; + static Coding tokenCoding7096_19[]; + void TokenFunc7096(x64Operand &operand, int tokenPos); + static Coding tokenCoding7100_16[]; + static Coding tokenCoding7100_17[]; + static Coding tokenCoding7100_18[]; + static Coding tokenCoding7100_19[]; + void TokenFunc7100(x64Operand &operand, int tokenPos); + static Coding tokenCoding7104_16[]; + static Coding tokenCoding7104_17[]; + static Coding tokenCoding7104_18[]; + static Coding tokenCoding7104_19[]; + void TokenFunc7104(x64Operand &operand, int tokenPos); + static Coding tokenCoding7108_16[]; + static Coding tokenCoding7108_17[]; + static Coding tokenCoding7108_18[]; + static Coding tokenCoding7108_19[]; + void TokenFunc7108(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7109[]; + static x64Token tokenBranches7110[]; + static x64Token tokenBranches7111[]; + static x64Token tokenBranches7112[]; + static Coding tokenCoding7113_16[]; + static Coding tokenCoding7113_17[]; + static Coding tokenCoding7113_18[]; + static Coding tokenCoding7113_19[]; + void TokenFunc7113(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7114[]; + static x64Token tokenBranches7115[]; + static x64Token tokenBranches7116[]; + static x64Token tokenBranches7117[]; + static Coding tokenCoding7118_16[]; + static Coding tokenCoding7118_17[]; + static Coding tokenCoding7118_18[]; + static Coding tokenCoding7118_19[]; + void TokenFunc7118(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7119[]; + static x64Token tokenBranches7120[]; + static x64Token tokenBranches7121[]; + static x64Token tokenBranches7122[]; + static Coding tokenCoding7123_16[]; + static Coding tokenCoding7123_17[]; + static Coding tokenCoding7123_18[]; + static Coding tokenCoding7123_19[]; + void TokenFunc7123(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7124[]; + static x64Token tokenBranches7125[]; + static x64Token tokenBranches7126[]; + static x64Token tokenBranches7127[]; + static Coding tokenCoding7128_16[]; + static Coding tokenCoding7128_17[]; + static Coding tokenCoding7128_18[]; + static Coding tokenCoding7128_19[]; + void TokenFunc7128(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7129[]; + static x64Token tokenBranches7130[]; + static Coding tokenCoding7131_16[]; + static Coding tokenCoding7131_17[]; + static Coding tokenCoding7131_18[]; + static Coding tokenCoding7131_19[]; + void TokenFunc7131(x64Operand &operand, int tokenPos); + static Coding tokenCoding7134_16[]; + static Coding tokenCoding7134_17[]; + static Coding tokenCoding7134_18[]; + static Coding tokenCoding7134_19[]; + void TokenFunc7134(x64Operand &operand, int tokenPos); + static Coding tokenCoding7137_16[]; + static Coding tokenCoding7137_17[]; + static Coding tokenCoding7137_18[]; + static Coding tokenCoding7137_19[]; + void TokenFunc7137(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7138[]; + static x64Token tokenBranches7139[]; + void TokenFunc7140(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7140[]; + static x64Token tokenBranches7141[]; + static x64Token tokenBranches7142[]; + void TokenFunc7143(x64Operand &operand, int tokenPos); + void TokenFunc7146(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7146[]; + static x64Token tokenBranches7147[]; + void TokenFunc7148(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7148[]; + static x64Token tokenBranches7149[]; + static x64Token tokenBranches7150[]; + void TokenFunc7151(x64Operand &operand, int tokenPos); + void TokenFunc7154(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7154[]; + static x64Token tokenBranches7155[]; + static x64Token tokenBranches7156[]; + void TokenFunc7157(x64Operand &operand, int tokenPos); + void TokenFunc7162(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7162[]; + static x64Token tokenBranches7163[]; + static x64Token tokenBranches7164[]; + void TokenFunc7165(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7166[]; + static x64Token tokenBranches7167[]; + void TokenFunc7168(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7168[]; + static x64Token tokenBranches7169[]; + static x64Token tokenBranches7170[]; + void TokenFunc7171(x64Operand &operand, int tokenPos); + void TokenFunc7174(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7174[]; + static x64Token tokenBranches7175[]; + void TokenFunc7176(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7176[]; + static x64Token tokenBranches7177[]; + static x64Token tokenBranches7178[]; + void TokenFunc7179(x64Operand &operand, int tokenPos); + void TokenFunc7182(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7182[]; + static x64Token tokenBranches7183[]; + static x64Token tokenBranches7184[]; + void TokenFunc7185(x64Operand &operand, int tokenPos); + void TokenFunc7190(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7190[]; + static x64Token tokenBranches7191[]; + static x64Token tokenBranches7192[]; + void TokenFunc7193(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7194[]; + static x64Token tokenBranches7195[]; + void TokenFunc7196(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7196[]; + static x64Token tokenBranches7197[]; + static x64Token tokenBranches7198[]; + void TokenFunc7199(x64Operand &operand, int tokenPos); + void TokenFunc7202(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7202[]; + static x64Token tokenBranches7203[]; + void TokenFunc7204(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7204[]; + static x64Token tokenBranches7205[]; + static x64Token tokenBranches7206[]; + void TokenFunc7207(x64Operand &operand, int tokenPos); + void TokenFunc7210(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7210[]; + static x64Token tokenBranches7211[]; + static x64Token tokenBranches7212[]; + void TokenFunc7213(x64Operand &operand, int tokenPos); + void TokenFunc7218(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7218[]; + static x64Token tokenBranches7219[]; + static x64Token tokenBranches7220[]; + void TokenFunc7221(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7223[]; + static x64Token tokenBranches7224[]; + static Coding tokenCoding7225_16[]; + static Coding tokenCoding7225_17[]; + static Coding tokenCoding7225_18[]; + static Coding tokenCoding7225_19[]; + void TokenFunc7225(x64Operand &operand, int tokenPos); + static Coding tokenCoding7229_16[]; + static Coding tokenCoding7229_17[]; + static Coding tokenCoding7229_23[]; + static Coding tokenCoding7229_18[]; + static Coding tokenCoding7229_19[]; + void TokenFunc7229(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7231[]; + static x64Token tokenBranches7232[]; + static Coding tokenCoding7233_16[]; + static Coding tokenCoding7233_17[]; + static Coding tokenCoding7233_18[]; + static Coding tokenCoding7233_19[]; + void TokenFunc7233(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7235[]; + static x64Token tokenBranches7236[]; + static Coding tokenCoding7237_16[]; + static Coding tokenCoding7237_17[]; + static Coding tokenCoding7237_18[]; + static Coding tokenCoding7237_19[]; + void TokenFunc7237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7238[]; + static x64Token tokenBranches7239[]; + static x64Token tokenBranches7240[]; + static Coding tokenCoding7241_16[]; + static Coding tokenCoding7241_17[]; + static Coding tokenCoding7241_18[]; + static Coding tokenCoding7241_19[]; + void TokenFunc7241(x64Operand &operand, int tokenPos); + void TokenFunc7242(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7242[]; + static x64Token tokenBranches7243[]; + static x64Token tokenBranches7244[]; + static Coding tokenCoding7245_16[]; + static Coding tokenCoding7245_17[]; + static Coding tokenCoding7245_18[]; + static Coding tokenCoding7245_19[]; + void TokenFunc7245(x64Operand &operand, int tokenPos); + static Coding tokenCoding7248_16[]; + static Coding tokenCoding7248_17[]; + static Coding tokenCoding7248_18[]; + static Coding tokenCoding7248_19[]; + void TokenFunc7248(x64Operand &operand, int tokenPos); + static Coding tokenCoding7251_16[]; + static Coding tokenCoding7251_17[]; + static Coding tokenCoding7251_18[]; + static Coding tokenCoding7251_19[]; + void TokenFunc7251(x64Operand &operand, int tokenPos); + static Coding tokenCoding7254_16[]; + static Coding tokenCoding7254_17[]; + static Coding tokenCoding7254_18[]; + static Coding tokenCoding7254_19[]; + void TokenFunc7254(x64Operand &operand, int tokenPos); + static Coding tokenCoding7258_16[]; + static Coding tokenCoding7258_17[]; + static Coding tokenCoding7258_18[]; + static Coding tokenCoding7258_19[]; + void TokenFunc7258(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7259[]; + static x64Token tokenBranches7260[]; + static Coding tokenCoding7261_16[]; + static Coding tokenCoding7261_17[]; + static Coding tokenCoding7261_18[]; + static Coding tokenCoding7261_19[]; + void TokenFunc7261(x64Operand &operand, int tokenPos); + static Coding tokenCoding7264_16[]; + static Coding tokenCoding7264_17[]; + static Coding tokenCoding7264_18[]; + static Coding tokenCoding7264_19[]; + void TokenFunc7264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7265[]; + static x64Token tokenBranches7266[]; + static Coding tokenCoding7267_16[]; + static Coding tokenCoding7267_17[]; + static Coding tokenCoding7267_18[]; + static Coding tokenCoding7267_19[]; + void TokenFunc7267(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7268[]; + static x64Token tokenBranches7269[]; + static x64Token tokenBranches7270[]; + static Coding tokenCoding7271_18[]; + static Coding tokenCoding7271_19[]; + void TokenFunc7271(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7274[]; + static Coding tokenCoding7275_18[]; + static Coding tokenCoding7275_19[]; + void TokenFunc7275(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7278[]; + static Coding tokenCoding7279_18[]; + static Coding tokenCoding7279_19[]; + void TokenFunc7279(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7282[]; + static Coding tokenCoding7283_18[]; + static Coding tokenCoding7283_19[]; + void TokenFunc7283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7284[]; + static x64Token tokenBranches7285[]; + static x64Token tokenBranches7286[]; + static x64Token tokenBranches7287[]; + static x64Token tokenBranches7288[]; + static x64Token tokenBranches7289[]; + static x64Token tokenBranches7290[]; + static x64Token tokenBranches7291[]; + static x64Token tokenBranches7292[]; + static x64Token tokenBranches7293[]; + static x64Token tokenBranches7294[]; + static x64Token tokenBranches7295[]; + static x64Token tokenBranches7296[]; + void TokenFunc7297(x64Operand &operand, int tokenPos); + void TokenFunc7307(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7307[]; + static x64Token tokenBranches7308[]; + static x64Token tokenBranches7309[]; + void TokenFunc7310(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7315[]; + static x64Token tokenBranches7316[]; + static x64Token tokenBranches7317[]; + static x64Token tokenBranches7318[]; + static x64Token tokenBranches7319[]; + static x64Token tokenBranches7320[]; + static x64Token tokenBranches7321[]; + static x64Token tokenBranches7322[]; + void TokenFunc7323(x64Operand &operand, int tokenPos); + void TokenFunc7333(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7333[]; + static x64Token tokenBranches7334[]; + static x64Token tokenBranches7335[]; + void TokenFunc7336(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7338[]; + static x64Token tokenBranches7339[]; + static x64Token tokenBranches7340[]; + static x64Token tokenBranches7341[]; + static x64Token tokenBranches7342[]; + static x64Token tokenBranches7343[]; + static x64Token tokenBranches7344[]; + void TokenFunc7345(x64Operand &operand, int tokenPos); + void TokenFunc7353(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7353[]; + static x64Token tokenBranches7354[]; + static x64Token tokenBranches7355[]; + void TokenFunc7356(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7357[]; + static x64Token tokenBranches7358[]; + static x64Token tokenBranches7359[]; + static x64Token tokenBranches7360[]; + static x64Token tokenBranches7361[]; + static x64Token tokenBranches7362[]; + static x64Token tokenBranches7363[]; + static x64Token tokenBranches7364[]; + static x64Token tokenBranches7365[]; + static x64Token tokenBranches7366[]; + static x64Token tokenBranches7367[]; + static x64Token tokenBranches7368[]; + void TokenFunc7369(x64Operand &operand, int tokenPos); + void TokenFunc7379(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7379[]; + static x64Token tokenBranches7380[]; + static x64Token tokenBranches7381[]; + void TokenFunc7382(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7387[]; + static x64Token tokenBranches7388[]; + static x64Token tokenBranches7389[]; + static x64Token tokenBranches7390[]; + static x64Token tokenBranches7391[]; + static x64Token tokenBranches7392[]; + static x64Token tokenBranches7393[]; + static x64Token tokenBranches7394[]; + void TokenFunc7395(x64Operand &operand, int tokenPos); + void TokenFunc7405(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7405[]; + static x64Token tokenBranches7406[]; + static x64Token tokenBranches7407[]; + void TokenFunc7408(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7410[]; + static x64Token tokenBranches7411[]; + static x64Token tokenBranches7412[]; + static x64Token tokenBranches7413[]; + static x64Token tokenBranches7414[]; + static x64Token tokenBranches7415[]; + static x64Token tokenBranches7416[]; + void TokenFunc7417(x64Operand &operand, int tokenPos); + void TokenFunc7425(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7425[]; + static x64Token tokenBranches7426[]; + static x64Token tokenBranches7427[]; + void TokenFunc7428(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7429[]; + static x64Token tokenBranches7430[]; + static x64Token tokenBranches7431[]; + static x64Token tokenBranches7432[]; + static x64Token tokenBranches7433[]; + static x64Token tokenBranches7434[]; + static x64Token tokenBranches7435[]; + static x64Token tokenBranches7436[]; + static x64Token tokenBranches7437[]; + static x64Token tokenBranches7438[]; + static x64Token tokenBranches7439[]; + static x64Token tokenBranches7440[]; + void TokenFunc7441(x64Operand &operand, int tokenPos); + void TokenFunc7451(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7451[]; + static x64Token tokenBranches7452[]; + static x64Token tokenBranches7453[]; + void TokenFunc7454(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7459[]; + static x64Token tokenBranches7460[]; + static x64Token tokenBranches7461[]; + static x64Token tokenBranches7462[]; + static x64Token tokenBranches7463[]; + static x64Token tokenBranches7464[]; + static x64Token tokenBranches7465[]; + static x64Token tokenBranches7466[]; + void TokenFunc7467(x64Operand &operand, int tokenPos); + void TokenFunc7477(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7477[]; + static x64Token tokenBranches7478[]; + static x64Token tokenBranches7479[]; + void TokenFunc7480(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7482[]; + static x64Token tokenBranches7483[]; + static x64Token tokenBranches7484[]; + static x64Token tokenBranches7485[]; + static x64Token tokenBranches7486[]; + static x64Token tokenBranches7487[]; + static x64Token tokenBranches7488[]; + void TokenFunc7489(x64Operand &operand, int tokenPos); + void TokenFunc7497(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7497[]; + static x64Token tokenBranches7498[]; + static x64Token tokenBranches7499[]; + void TokenFunc7500(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7501[]; + static x64Token tokenBranches7502[]; + static x64Token tokenBranches7503[]; + static x64Token tokenBranches7504[]; + static x64Token tokenBranches7505[]; + static x64Token tokenBranches7506[]; + static x64Token tokenBranches7507[]; + static x64Token tokenBranches7508[]; + static x64Token tokenBranches7509[]; + static x64Token tokenBranches7510[]; + static x64Token tokenBranches7511[]; + static x64Token tokenBranches7512[]; + void TokenFunc7513(x64Operand &operand, int tokenPos); + void TokenFunc7523(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7523[]; + static x64Token tokenBranches7524[]; + static x64Token tokenBranches7525[]; + void TokenFunc7526(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7528[]; + static x64Token tokenBranches7529[]; + static x64Token tokenBranches7530[]; + static x64Token tokenBranches7531[]; + static x64Token tokenBranches7532[]; + static x64Token tokenBranches7533[]; + static x64Token tokenBranches7534[]; + void TokenFunc7535(x64Operand &operand, int tokenPos); + void TokenFunc7543(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7543[]; + static x64Token tokenBranches7544[]; + static x64Token tokenBranches7545[]; + void TokenFunc7546(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7547[]; + void TokenFunc7548(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7548[]; + static x64Token tokenBranches7549[]; + static x64Token tokenBranches7550[]; + static Coding tokenCoding7551_16[]; + static Coding tokenCoding7551_17[]; + static Coding tokenCoding7551_18[]; + static Coding tokenCoding7551_19[]; + void TokenFunc7551(x64Operand &operand, int tokenPos); + void TokenFunc7552(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7552[]; + static x64Token tokenBranches7553[]; + static x64Token tokenBranches7554[]; + static Coding tokenCoding7555_16[]; + static Coding tokenCoding7555_17[]; + static Coding tokenCoding7555_18[]; + static Coding tokenCoding7555_19[]; + void TokenFunc7555(x64Operand &operand, int tokenPos); + void TokenFunc7556(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7556[]; + static x64Token tokenBranches7557[]; + static x64Token tokenBranches7558[]; + static Coding tokenCoding7559_16[]; + static Coding tokenCoding7559_17[]; + static Coding tokenCoding7559_18[]; + static Coding tokenCoding7559_19[]; + void TokenFunc7559(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7560[]; + static x64Token tokenBranches7561[]; + static x64Token tokenBranches7562[]; + static Coding tokenCoding7563_16[]; + static Coding tokenCoding7563_17[]; + static Coding tokenCoding7563_18[]; + static Coding tokenCoding7563_19[]; + void TokenFunc7563(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7564[]; + static x64Token tokenBranches7565[]; + static x64Token tokenBranches7566[]; + static Coding tokenCoding7567_16[]; + static Coding tokenCoding7567_17[]; + static Coding tokenCoding7567_18[]; + static Coding tokenCoding7567_19[]; + void TokenFunc7567(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7568[]; + static x64Token tokenBranches7569[]; + static x64Token tokenBranches7570[]; + static Coding tokenCoding7571_16[]; + static Coding tokenCoding7571_17[]; + static Coding tokenCoding7571_18[]; + static Coding tokenCoding7571_19[]; + void TokenFunc7571(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7574[]; + void TokenFunc7575(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7575[]; + static x64Token tokenBranches7576[]; + static Coding tokenCoding7577_16[]; + static Coding tokenCoding7577_17[]; + static Coding tokenCoding7577_23[]; + static Coding tokenCoding7577_18[]; + static Coding tokenCoding7577_19[]; + void TokenFunc7577(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7578[]; + static x64Token tokenBranches7579[]; + static Coding tokenCoding7580_16[]; + static Coding tokenCoding7580_17[]; + static Coding tokenCoding7580_23[]; + static Coding tokenCoding7580_18[]; + static Coding tokenCoding7580_19[]; + void TokenFunc7580(x64Operand &operand, int tokenPos); + void TokenFunc7581(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7582[]; + void TokenFunc7583(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7586[]; + void TokenFunc7587(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7587[]; + static x64Token tokenBranches7588[]; + static Coding tokenCoding7589_16[]; + static Coding tokenCoding7589_17[]; + static Coding tokenCoding7589_18[]; + static Coding tokenCoding7589_19[]; + void TokenFunc7589(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7592[]; + static Coding tokenCoding7593_16[]; + static Coding tokenCoding7593_17[]; + static Coding tokenCoding7593_18[]; + static Coding tokenCoding7593_19[]; + void TokenFunc7593(x64Operand &operand, int tokenPos); + void TokenFunc7594(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7594[]; + static x64Token tokenBranches7595[]; + static Coding tokenCoding7596_16[]; + static Coding tokenCoding7596_17[]; + static Coding tokenCoding7596_18[]; + static Coding tokenCoding7596_19[]; + void TokenFunc7596(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7599[]; + static Coding tokenCoding7600_16[]; + static Coding tokenCoding7600_17[]; + static Coding tokenCoding7600_18[]; + static Coding tokenCoding7600_19[]; + void TokenFunc7600(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7606[]; + static x64Token tokenBranches7607[]; + void TokenFunc7608(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7608[]; + static x64Token tokenBranches7609[]; + void TokenFunc7610(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7611[]; + void TokenFunc7612(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7612[]; + static x64Token tokenBranches7613[]; + void TokenFunc7614(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7615[]; + void TokenFunc7616(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7616[]; + static x64Token tokenBranches7617[]; + void TokenFunc7618(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7619[]; + void TokenFunc7620(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7620[]; + static x64Token tokenBranches7621[]; + void TokenFunc7622(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7623[]; + static x64Token tokenBranches7624[]; + void TokenFunc7625(x64Operand &operand, int tokenPos); + void TokenFunc7628(x64Operand &operand, int tokenPos); + void TokenFunc7631(x64Operand &operand, int tokenPos); + void TokenFunc7634(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7635[]; + static x64Token tokenBranches7636[]; + static x64Token tokenBranches7637[]; + static x64Token tokenBranches7638[]; + static x64Token tokenBranches7639[]; + static x64Token tokenBranches7640[]; + static x64Token tokenBranches7641[]; + static x64Token tokenBranches7642[]; + void TokenFunc7643(x64Operand &operand, int tokenPos); + void TokenFunc7648(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7648[]; + static x64Token tokenBranches7649[]; + static x64Token tokenBranches7650[]; + void TokenFunc7651(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7658[]; + void TokenFunc7659(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7666[]; + void TokenFunc7667(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7672[]; + void TokenFunc7673(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7680[]; + void TokenFunc7681(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7684[]; + static x64Token tokenBranches7685[]; + static x64Token tokenBranches7686[]; + static x64Token tokenBranches7687[]; + static x64Token tokenBranches7688[]; + void TokenFunc7689(x64Operand &operand, int tokenPos); + void TokenFunc7694(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7694[]; + static x64Token tokenBranches7695[]; + static x64Token tokenBranches7696[]; + void TokenFunc7697(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7704[]; + void TokenFunc7705(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7712[]; + void TokenFunc7713(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7718[]; + void TokenFunc7719(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7726[]; + void TokenFunc7727(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7730[]; + static x64Token tokenBranches7731[]; + static x64Token tokenBranches7732[]; + static x64Token tokenBranches7733[]; + static x64Token tokenBranches7734[]; + void TokenFunc7735(x64Operand &operand, int tokenPos); + void TokenFunc7740(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7740[]; + static x64Token tokenBranches7741[]; + static x64Token tokenBranches7742[]; + void TokenFunc7743(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7750[]; + void TokenFunc7751(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7758[]; + void TokenFunc7759(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7764[]; + void TokenFunc7765(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7772[]; + void TokenFunc7773(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7777[]; + void TokenFunc7778(x64Operand &operand, int tokenPos); + void TokenFunc7779(x64Operand &operand, int tokenPos); + void TokenFunc7780(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7781[]; + static Coding tokenCoding7782_16[]; + static Coding tokenCoding7782_17[]; + static Coding tokenCoding7782_18[]; + static Coding tokenCoding7782_19[]; + void TokenFunc7782(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7783[]; + static Coding tokenCoding7784_16[]; + static Coding tokenCoding7784_17[]; + static Coding tokenCoding7784_18[]; + static Coding tokenCoding7784_19[]; + void TokenFunc7784(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7785[]; + static Coding tokenCoding7786_16[]; + static Coding tokenCoding7786_17[]; + static Coding tokenCoding7786_18[]; + static Coding tokenCoding7786_19[]; + void TokenFunc7786(x64Operand &operand, int tokenPos); + void TokenFunc7787(x64Operand &operand, int tokenPos); + void TokenFunc7788(x64Operand &operand, int tokenPos); + void TokenFunc7789(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7798[]; + static Coding tokenCoding7799_34[]; + static Coding tokenCoding7799_16[]; + static Coding tokenCoding7799_17[]; + static Coding tokenCoding7799_35[]; + static Coding tokenCoding7799_18[]; + static Coding tokenCoding7799_19[]; + void TokenFunc7799(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7800[]; + static Coding tokenCoding7801_34[]; + static Coding tokenCoding7801_16[]; + static Coding tokenCoding7801_17[]; + static Coding tokenCoding7801_35[]; + static Coding tokenCoding7801_18[]; + static Coding tokenCoding7801_19[]; + void TokenFunc7801(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7802[]; + static Coding tokenCoding7803_34[]; + static Coding tokenCoding7803_16[]; + static Coding tokenCoding7803_17[]; + static Coding tokenCoding7803_35[]; + static Coding tokenCoding7803_18[]; + static Coding tokenCoding7803_19[]; + void TokenFunc7803(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7804[]; + static Coding tokenCoding7805_34[]; + static Coding tokenCoding7805_16[]; + static Coding tokenCoding7805_17[]; + static Coding tokenCoding7805_35[]; + static Coding tokenCoding7805_18[]; + static Coding tokenCoding7805_19[]; + void TokenFunc7805(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7806[]; + void TokenFunc7807(x64Operand &operand, int tokenPos); + void TokenFunc7808(x64Operand &operand, int tokenPos); + void TokenFunc7809(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7810[]; + void TokenFunc7811(x64Operand &operand, int tokenPos); + void TokenFunc7812(x64Operand &operand, int tokenPos); + void TokenFunc7813(x64Operand &operand, int tokenPos); + void TokenFunc7814(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7815[]; + void TokenFunc7816(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7817[]; + void TokenFunc7818(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7819[]; + void TokenFunc7820(x64Operand &operand, int tokenPos); + static Coding tokenCoding7822_16[]; + static Coding tokenCoding7822_17[]; + static Coding tokenCoding7822_18[]; + static Coding tokenCoding7822_19[]; + void TokenFunc7822(x64Operand &operand, int tokenPos); + static Coding tokenCoding7824_16[]; + static Coding tokenCoding7824_17[]; + static Coding tokenCoding7824_18[]; + static Coding tokenCoding7824_19[]; + void TokenFunc7824(x64Operand &operand, int tokenPos); + static Coding tokenCoding7826_16[]; + static Coding tokenCoding7826_17[]; + static Coding tokenCoding7826_18[]; + static Coding tokenCoding7826_19[]; + void TokenFunc7826(x64Operand &operand, int tokenPos); + void TokenFunc7827(x64Operand &operand, int tokenPos); + void TokenFunc7828(x64Operand &operand, int tokenPos); + void TokenFunc7829(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7842[]; + void TokenFunc7843(x64Operand &operand, int tokenPos); + void TokenFunc7844(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7845[]; + void TokenFunc7846(x64Operand &operand, int tokenPos); + void TokenFunc7847(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7855[]; + static x64Token tokenBranches7856[]; + static x64Token tokenBranches7857[]; + static x64Token tokenBranches7858[]; + static x64Token tokenBranches7859[]; + static x64Token tokenBranches7860[]; + void TokenFunc7861(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7863[]; + void TokenFunc7864(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7864[]; + static x64Token tokenBranches7865[]; + static x64Token tokenBranches7866[]; + void TokenFunc7867(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7872[]; + void TokenFunc7873(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7878[]; + void TokenFunc7879(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7882[]; + void TokenFunc7883(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7888[]; + void TokenFunc7889(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7890[]; + static x64Token tokenBranches7891[]; + static x64Token tokenBranches7892[]; + static x64Token tokenBranches7893[]; + static x64Token tokenBranches7894[]; + void TokenFunc7895(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7897[]; + void TokenFunc7898(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7898[]; + static x64Token tokenBranches7899[]; + static x64Token tokenBranches7900[]; + void TokenFunc7901(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7906[]; + void TokenFunc7907(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7912[]; + void TokenFunc7913(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7916[]; + void TokenFunc7917(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7922[]; + void TokenFunc7923(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7924[]; + static x64Token tokenBranches7925[]; + static x64Token tokenBranches7926[]; + static x64Token tokenBranches7927[]; + static x64Token tokenBranches7928[]; + void TokenFunc7929(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7931[]; + void TokenFunc7932(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7932[]; + static x64Token tokenBranches7933[]; + static x64Token tokenBranches7934[]; + void TokenFunc7935(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7940[]; + void TokenFunc7941(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7946[]; + void TokenFunc7947(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7950[]; + void TokenFunc7951(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7956[]; + void TokenFunc7957(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7958[]; + static x64Token tokenBranches7959[]; + static x64Token tokenBranches7960[]; + static x64Token tokenBranches7961[]; + static x64Token tokenBranches7962[]; + void TokenFunc7963(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7965[]; + void TokenFunc7966(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7966[]; + static x64Token tokenBranches7967[]; + static x64Token tokenBranches7968[]; + void TokenFunc7969(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7972[]; + void TokenFunc7973(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7978[]; + void TokenFunc7979(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7983[]; + void TokenFunc7984(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8023[]; + static Coding tokenCoding8024_16[]; + static Coding tokenCoding8024_17[]; + static Coding tokenCoding8024_18[]; + static Coding tokenCoding8024_19[]; + void TokenFunc8024(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8028[]; + static x64Token tokenBranches8029[]; + static x64Token tokenBranches8030[]; + static x64Token tokenBranches8031[]; + static x64Token tokenBranches8032[]; + static x64Token tokenBranches8033[]; + void TokenFunc8034(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8036[]; + void TokenFunc8037(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8037[]; + static x64Token tokenBranches8038[]; + static x64Token tokenBranches8039[]; + void TokenFunc8040(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8045[]; + void TokenFunc8046(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8051[]; + void TokenFunc8052(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8055[]; + void TokenFunc8056(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8061[]; + void TokenFunc8062(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8063[]; + static x64Token tokenBranches8064[]; + static x64Token tokenBranches8065[]; + static x64Token tokenBranches8066[]; + static x64Token tokenBranches8067[]; + void TokenFunc8068(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8070[]; + void TokenFunc8071(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8071[]; + static x64Token tokenBranches8072[]; + static x64Token tokenBranches8073[]; + void TokenFunc8074(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8079[]; + void TokenFunc8080(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8085[]; + void TokenFunc8086(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8089[]; + void TokenFunc8090(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8095[]; + void TokenFunc8096(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8097[]; + static x64Token tokenBranches8098[]; + static x64Token tokenBranches8099[]; + static x64Token tokenBranches8100[]; + static x64Token tokenBranches8101[]; + void TokenFunc8102(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8104[]; + void TokenFunc8105(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8105[]; + static x64Token tokenBranches8106[]; + static x64Token tokenBranches8107[]; + void TokenFunc8108(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8113[]; + void TokenFunc8114(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8119[]; + void TokenFunc8120(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8123[]; + void TokenFunc8124(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8129[]; + void TokenFunc8130(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8131[]; + static x64Token tokenBranches8132[]; + static x64Token tokenBranches8133[]; + static x64Token tokenBranches8134[]; + static x64Token tokenBranches8135[]; + void TokenFunc8136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8138[]; + void TokenFunc8139(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8139[]; + static x64Token tokenBranches8140[]; + static x64Token tokenBranches8141[]; + void TokenFunc8142(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8145[]; + void TokenFunc8146(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8151[]; + void TokenFunc8152(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8156[]; + void TokenFunc8157(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8158[]; + static Coding tokenCoding8159_16[]; + static Coding tokenCoding8159_17[]; + static Coding tokenCoding8159_18[]; + static Coding tokenCoding8159_19[]; + void TokenFunc8159(x64Operand &operand, int tokenPos); + static Coding tokenCoding8160_16[]; + static Coding tokenCoding8160_17[]; + static Coding tokenCoding8160_18[]; + static Coding tokenCoding8160_19[]; + void TokenFunc8160(x64Operand &operand, int tokenPos); + static Coding tokenCoding8161_16[]; + static Coding tokenCoding8161_17[]; + static Coding tokenCoding8161_18[]; + static Coding tokenCoding8161_19[]; + void TokenFunc8161(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8167[]; + static x64Token tokenBranches8168[]; + static x64Token tokenBranches8169[]; + static x64Token tokenBranches8170[]; + void TokenFunc8171(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8172[]; + static x64Token tokenBranches8173[]; + static x64Token tokenBranches8174[]; + void TokenFunc8175(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8176[]; + static x64Token tokenBranches8177[]; + static x64Token tokenBranches8178[]; + void TokenFunc8179(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8180[]; + static x64Token tokenBranches8181[]; + static x64Token tokenBranches8182[]; + void TokenFunc8183(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8184[]; + static x64Token tokenBranches8185[]; + static x64Token tokenBranches8186[]; + static Coding tokenCoding8187_16[]; + static Coding tokenCoding8187_17[]; + static Coding tokenCoding8187_18[]; + static Coding tokenCoding8187_19[]; + void TokenFunc8187(x64Operand &operand, int tokenPos); + static Coding tokenCoding8191_16[]; + static Coding tokenCoding8191_17[]; + static Coding tokenCoding8191_23[]; + static Coding tokenCoding8191_18[]; + static Coding tokenCoding8191_19[]; + void TokenFunc8191(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8192[]; + static x64Token tokenBranches8193[]; + static x64Token tokenBranches8194[]; + static Coding tokenCoding8195_16[]; + static Coding tokenCoding8195_17[]; + static Coding tokenCoding8195_18[]; + static Coding tokenCoding8195_19[]; + void TokenFunc8195(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8196[]; + static x64Token tokenBranches8197[]; + static x64Token tokenBranches8198[]; + static Coding tokenCoding8199_16[]; + static Coding tokenCoding8199_17[]; + static Coding tokenCoding8199_18[]; + static Coding tokenCoding8199_19[]; + void TokenFunc8199(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8200[]; + static x64Token tokenBranches8201[]; + static x64Token tokenBranches8202[]; + static Coding tokenCoding8203_16[]; + static Coding tokenCoding8203_17[]; + static Coding tokenCoding8203_18[]; + static Coding tokenCoding8203_19[]; + void TokenFunc8203(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8204[]; + static x64Token tokenBranches8205[]; + static Coding tokenCoding8206_16[]; + static Coding tokenCoding8206_17[]; + static Coding tokenCoding8206_18[]; + static Coding tokenCoding8206_19[]; + void TokenFunc8206(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8207[]; + static x64Token tokenBranches8208[]; + static Coding tokenCoding8209_16[]; + static Coding tokenCoding8209_17[]; + static Coding tokenCoding8209_23[]; + static Coding tokenCoding8209_18[]; + static Coding tokenCoding8209_19[]; + void TokenFunc8209(x64Operand &operand, int tokenPos); + static Coding tokenCoding8212_16[]; + static Coding tokenCoding8212_17[]; + static Coding tokenCoding8212_23[]; + static Coding tokenCoding8212_18[]; + static Coding tokenCoding8212_19[]; + void TokenFunc8212(x64Operand &operand, int tokenPos); + static Coding tokenCoding8215_16[]; + static Coding tokenCoding8215_17[]; + static Coding tokenCoding8215_23[]; + static Coding tokenCoding8215_18[]; + static Coding tokenCoding8215_19[]; + void TokenFunc8215(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8216[]; + static x64Token tokenBranches8217[]; + static Coding tokenCoding8218_16[]; + static Coding tokenCoding8218_17[]; + static Coding tokenCoding8218_18[]; + static Coding tokenCoding8218_19[]; + void TokenFunc8218(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8219[]; + static x64Token tokenBranches8220[]; + static Coding tokenCoding8221_16[]; + static Coding tokenCoding8221_17[]; + static Coding tokenCoding8221_18[]; + static Coding tokenCoding8221_19[]; + void TokenFunc8221(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8222[]; + static x64Token tokenBranches8223[]; + static Coding tokenCoding8224_16[]; + static Coding tokenCoding8224_17[]; + static Coding tokenCoding8224_18[]; + static Coding tokenCoding8224_19[]; + void TokenFunc8224(x64Operand &operand, int tokenPos); + void TokenFunc8225(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8225[]; + static x64Token tokenBranches8226[]; + static x64Token tokenBranches8227[]; + static Coding tokenCoding8228_16[]; + static Coding tokenCoding8228_17[]; + static Coding tokenCoding8228_18[]; + static Coding tokenCoding8228_19[]; + void TokenFunc8228(x64Operand &operand, int tokenPos); + void TokenFunc8229(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8229[]; + static x64Token tokenBranches8230[]; + static x64Token tokenBranches8231[]; + static Coding tokenCoding8232_16[]; + static Coding tokenCoding8232_17[]; + static Coding tokenCoding8232_23[]; + static Coding tokenCoding8232_18[]; + static Coding tokenCoding8232_19[]; + void TokenFunc8232(x64Operand &operand, int tokenPos); + void TokenFunc8233(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8233[]; + static x64Token tokenBranches8234[]; + static x64Token tokenBranches8235[]; + static Coding tokenCoding8236_16[]; + static Coding tokenCoding8236_17[]; + static Coding tokenCoding8236_18[]; + static Coding tokenCoding8236_19[]; + void TokenFunc8236(x64Operand &operand, int tokenPos); + void TokenFunc8237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8237[]; + static x64Token tokenBranches8238[]; + static x64Token tokenBranches8239[]; + static Coding tokenCoding8240_16[]; + static Coding tokenCoding8240_17[]; + static Coding tokenCoding8240_18[]; + static Coding tokenCoding8240_19[]; + void TokenFunc8240(x64Operand &operand, int tokenPos); + void TokenFunc8241(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8241[]; + static x64Token tokenBranches8242[]; + static x64Token tokenBranches8243[]; + static Coding tokenCoding8244_16[]; + static Coding tokenCoding8244_17[]; + static Coding tokenCoding8244_18[]; + static Coding tokenCoding8244_19[]; + void TokenFunc8244(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8247[]; + static Coding tokenCoding8248_16[]; + static Coding tokenCoding8248_17[]; + static Coding tokenCoding8248_18[]; + static Coding tokenCoding8248_19[]; + void TokenFunc8248(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8251[]; + static Coding tokenCoding8252_16[]; + static Coding tokenCoding8252_17[]; + static Coding tokenCoding8252_18[]; + static Coding tokenCoding8252_19[]; + void TokenFunc8252(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8255[]; + static Coding tokenCoding8256_16[]; + static Coding tokenCoding8256_17[]; + static Coding tokenCoding8256_18[]; + static Coding tokenCoding8256_19[]; + void TokenFunc8256(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8259[]; + static Coding tokenCoding8260_16[]; + static Coding tokenCoding8260_17[]; + static Coding tokenCoding8260_18[]; + static Coding tokenCoding8260_19[]; + void TokenFunc8260(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8261[]; + static x64Token tokenBranches8262[]; + static x64Token tokenBranches8263[]; + static x64Token tokenBranches8264[]; + static Coding tokenCoding8265_16[]; + static Coding tokenCoding8265_17[]; + static Coding tokenCoding8265_18[]; + static Coding tokenCoding8265_19[]; + void TokenFunc8265(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8266[]; + static x64Token tokenBranches8267[]; + static x64Token tokenBranches8268[]; + static x64Token tokenBranches8269[]; + static Coding tokenCoding8270_16[]; + static Coding tokenCoding8270_17[]; + static Coding tokenCoding8270_18[]; + static Coding tokenCoding8270_19[]; + void TokenFunc8270(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8271[]; + static x64Token tokenBranches8272[]; + static x64Token tokenBranches8273[]; + static x64Token tokenBranches8274[]; + static Coding tokenCoding8275_16[]; + static Coding tokenCoding8275_17[]; + static Coding tokenCoding8275_18[]; + static Coding tokenCoding8275_19[]; + void TokenFunc8275(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8276[]; + static x64Token tokenBranches8277[]; + static x64Token tokenBranches8278[]; + static x64Token tokenBranches8279[]; + static Coding tokenCoding8280_16[]; + static Coding tokenCoding8280_17[]; + static Coding tokenCoding8280_18[]; + static Coding tokenCoding8280_19[]; + void TokenFunc8280(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8282[]; + static Coding tokenCoding8283_16[]; + static Coding tokenCoding8283_17[]; + static Coding tokenCoding8283_18[]; + static Coding tokenCoding8283_19[]; + void TokenFunc8283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8284[]; + static Coding tokenCoding8285_16[]; + static Coding tokenCoding8285_17[]; + static Coding tokenCoding8285_18[]; + static Coding tokenCoding8285_19[]; + void TokenFunc8285(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8289[]; + static x64Token tokenBranches8290[]; + static x64Token tokenBranches8291[]; + static x64Token tokenBranches8292[]; + static Coding tokenCoding8293_16[]; + static Coding tokenCoding8293_17[]; + static Coding tokenCoding8293_18[]; + static Coding tokenCoding8293_19[]; + void TokenFunc8293(x64Operand &operand, int tokenPos); + static Coding tokenCoding8297_16[]; + static Coding tokenCoding8297_17[]; + static Coding tokenCoding8297_23[]; + static Coding tokenCoding8297_18[]; + static Coding tokenCoding8297_19[]; + void TokenFunc8297(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8298[]; + static x64Token tokenBranches8299[]; + static x64Token tokenBranches8300[]; + static Coding tokenCoding8301_16[]; + static Coding tokenCoding8301_17[]; + static Coding tokenCoding8301_18[]; + static Coding tokenCoding8301_19[]; + void TokenFunc8301(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8302[]; + static x64Token tokenBranches8303[]; + static x64Token tokenBranches8304[]; + static Coding tokenCoding8305_16[]; + static Coding tokenCoding8305_17[]; + static Coding tokenCoding8305_18[]; + static Coding tokenCoding8305_19[]; + void TokenFunc8305(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8306[]; + static x64Token tokenBranches8307[]; + static x64Token tokenBranches8308[]; + static Coding tokenCoding8309_16[]; + static Coding tokenCoding8309_17[]; + static Coding tokenCoding8309_18[]; + static Coding tokenCoding8309_19[]; + void TokenFunc8309(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8310[]; + static x64Token tokenBranches8311[]; + static x64Token tokenBranches8312[]; + void TokenFunc8313(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8314[]; + static x64Token tokenBranches8315[]; + void TokenFunc8316(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8317[]; + static x64Token tokenBranches8318[]; + void TokenFunc8319(x64Operand &operand, int tokenPos); + void TokenFunc8320(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8320[]; + static x64Token tokenBranches8321[]; + void TokenFunc8322(x64Operand &operand, int tokenPos); + void TokenFunc8323(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8323[]; + static x64Token tokenBranches8324[]; + void TokenFunc8325(x64Operand &operand, int tokenPos); + void TokenFunc8326(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8326[]; + static x64Token tokenBranches8327[]; + void TokenFunc8328(x64Operand &operand, int tokenPos); + void TokenFunc8329(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8329[]; + static x64Token tokenBranches8330[]; + static x64Token tokenBranches8331[]; + static Coding tokenCoding8332_16[]; + static Coding tokenCoding8332_17[]; + static Coding tokenCoding8332_18[]; + static Coding tokenCoding8332_19[]; + void TokenFunc8332(x64Operand &operand, int tokenPos); + void TokenFunc8333(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8333[]; + static x64Token tokenBranches8334[]; + static x64Token tokenBranches8335[]; + static Coding tokenCoding8336_16[]; + static Coding tokenCoding8336_17[]; + static Coding tokenCoding8336_23[]; + static Coding tokenCoding8336_18[]; + static Coding tokenCoding8336_19[]; + void TokenFunc8336(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8339[]; + static Coding tokenCoding8340_16[]; + static Coding tokenCoding8340_17[]; + static Coding tokenCoding8340_18[]; + static Coding tokenCoding8340_19[]; + void TokenFunc8340(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8343[]; + static Coding tokenCoding8344_16[]; + static Coding tokenCoding8344_17[]; + static Coding tokenCoding8344_18[]; + static Coding tokenCoding8344_19[]; + void TokenFunc8344(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8347[]; + static Coding tokenCoding8348_16[]; + static Coding tokenCoding8348_17[]; + static Coding tokenCoding8348_18[]; + static Coding tokenCoding8348_19[]; + void TokenFunc8348(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8349[]; + static x64Token tokenBranches8350[]; + static x64Token tokenBranches8351[]; + static Coding tokenCoding8352_16[]; + static Coding tokenCoding8352_17[]; + static Coding tokenCoding8352_18[]; + static Coding tokenCoding8352_19[]; + void TokenFunc8352(x64Operand &operand, int tokenPos); + static Coding tokenCoding8356_16[]; + static Coding tokenCoding8356_17[]; + static Coding tokenCoding8356_23[]; + static Coding tokenCoding8356_18[]; + static Coding tokenCoding8356_19[]; + void TokenFunc8356(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8357[]; + static x64Token tokenBranches8358[]; + static x64Token tokenBranches8359[]; + static Coding tokenCoding8360_16[]; + static Coding tokenCoding8360_17[]; + static Coding tokenCoding8360_18[]; + static Coding tokenCoding8360_19[]; + void TokenFunc8360(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8361[]; + static x64Token tokenBranches8362[]; + static x64Token tokenBranches8363[]; + static Coding tokenCoding8364_16[]; + static Coding tokenCoding8364_17[]; + static Coding tokenCoding8364_18[]; + static Coding tokenCoding8364_19[]; + void TokenFunc8364(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8365[]; + static x64Token tokenBranches8366[]; + static x64Token tokenBranches8367[]; + static Coding tokenCoding8368_16[]; + static Coding tokenCoding8368_17[]; + static Coding tokenCoding8368_18[]; + static Coding tokenCoding8368_19[]; + void TokenFunc8368(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8369[]; + static x64Token tokenBranches8370[]; + static x64Token tokenBranches8371[]; + static x64Token tokenBranches8372[]; + static x64Token tokenBranches8373[]; + static x64Token tokenBranches8374[]; + void TokenFunc8375(x64Operand &operand, int tokenPos); + void TokenFunc8378(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8378[]; + static x64Token tokenBranches8379[]; + static x64Token tokenBranches8380[]; + void TokenFunc8381(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8386[]; + void TokenFunc8387(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8392[]; + void TokenFunc8393(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8398[]; + void TokenFunc8399(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8404[]; + void TokenFunc8405(x64Operand &operand, int tokenPos); + void TokenFunc8406(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8409[]; + static Coding tokenCoding8410_16[]; + static Coding tokenCoding8410_17[]; + static Coding tokenCoding8410_18[]; + static Coding tokenCoding8410_19[]; + void TokenFunc8410(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8411[]; + static Coding tokenCoding8412_16[]; + static Coding tokenCoding8412_17[]; + static Coding tokenCoding8412_18[]; + static Coding tokenCoding8412_19[]; + void TokenFunc8412(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8413[]; + static Coding tokenCoding8414_16[]; + static Coding tokenCoding8414_17[]; + static Coding tokenCoding8414_18[]; + static Coding tokenCoding8414_19[]; + void TokenFunc8414(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8415[]; + static Coding tokenCoding8416_16[]; + static Coding tokenCoding8416_17[]; + static Coding tokenCoding8416_18[]; + static Coding tokenCoding8416_19[]; + void TokenFunc8416(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8466[]; + void TokenFunc8467(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8467[]; + static x64Token tokenBranches8468[]; + static Coding tokenCoding8469_16[]; + static Coding tokenCoding8469_17[]; + static Coding tokenCoding8469_23[]; + static Coding tokenCoding8469_18[]; + static Coding tokenCoding8469_19[]; + void TokenFunc8469(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8470[]; + void TokenFunc8471(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8471[]; + static x64Token tokenBranches8472[]; + static Coding tokenCoding8473_16[]; + static Coding tokenCoding8473_17[]; + static Coding tokenCoding8473_23[]; + static Coding tokenCoding8473_18[]; + static Coding tokenCoding8473_19[]; + void TokenFunc8473(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8487[]; + void TokenFunc8488(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8488[]; + static x64Token tokenBranches8489[]; + static Coding tokenCoding8490_16[]; + static Coding tokenCoding8490_17[]; + static Coding tokenCoding8490_23[]; + static Coding tokenCoding8490_18[]; + static Coding tokenCoding8490_19[]; + void TokenFunc8490(x64Operand &operand, int tokenPos); + void TokenFunc8491(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8491[]; + static x64Token tokenBranches8492[]; + static Coding tokenCoding8493_16[]; + static Coding tokenCoding8493_17[]; + static Coding tokenCoding8493_23[]; + static Coding tokenCoding8493_18[]; + static Coding tokenCoding8493_19[]; + void TokenFunc8493(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8494[]; + static x64Token tokenBranches8495[]; + static Coding tokenCoding8496_16[]; + static Coding tokenCoding8496_17[]; + static Coding tokenCoding8496_23[]; + static Coding tokenCoding8496_18[]; + static Coding tokenCoding8496_19[]; + void TokenFunc8496(x64Operand &operand, int tokenPos); + static Coding tokenCoding8499_16[]; + static Coding tokenCoding8499_17[]; + static Coding tokenCoding8499_23[]; + static Coding tokenCoding8499_18[]; + static Coding tokenCoding8499_19[]; + void TokenFunc8499(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8500[]; + static x64Token tokenBranches8501[]; + static x64Token tokenBranches8502[]; + static Coding tokenCoding8503_16[]; + static Coding tokenCoding8503_17[]; + static Coding tokenCoding8503_23[]; + static Coding tokenCoding8503_18[]; + static Coding tokenCoding8503_19[]; + void TokenFunc8503(x64Operand &operand, int tokenPos); + void TokenFunc8504(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8504[]; + static x64Token tokenBranches8505[]; + static Coding tokenCoding8506_16[]; + static Coding tokenCoding8506_17[]; + static Coding tokenCoding8506_23[]; + static Coding tokenCoding8506_18[]; + static Coding tokenCoding8506_19[]; + void TokenFunc8506(x64Operand &operand, int tokenPos); + void TokenFunc8507(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8507[]; + static x64Token tokenBranches8508[]; + static Coding tokenCoding8509_16[]; + static Coding tokenCoding8509_17[]; + static Coding tokenCoding8509_23[]; + static Coding tokenCoding8509_18[]; + static Coding tokenCoding8509_19[]; + void TokenFunc8509(x64Operand &operand, int tokenPos); + static Coding tokenCoding8512_16[]; + static Coding tokenCoding8512_17[]; + static Coding tokenCoding8512_23[]; + static Coding tokenCoding8512_18[]; + static Coding tokenCoding8512_19[]; + void TokenFunc8512(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8513[]; + static x64Token tokenBranches8514[]; + static Coding tokenCoding8515_16[]; + static Coding tokenCoding8515_17[]; + static Coding tokenCoding8515_23[]; + static Coding tokenCoding8515_18[]; + static Coding tokenCoding8515_19[]; + void TokenFunc8515(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8516[]; + static x64Token tokenBranches8517[]; + static Coding tokenCoding8518_16[]; + static Coding tokenCoding8518_17[]; + static Coding tokenCoding8518_23[]; + static Coding tokenCoding8518_18[]; + static Coding tokenCoding8518_19[]; + void TokenFunc8518(x64Operand &operand, int tokenPos); + static Coding tokenCoding8521_16[]; + static Coding tokenCoding8521_17[]; + static Coding tokenCoding8521_23[]; + static Coding tokenCoding8521_18[]; + static Coding tokenCoding8521_19[]; + void TokenFunc8521(x64Operand &operand, int tokenPos); + static Coding tokenCoding8524_16[]; + static Coding tokenCoding8524_17[]; + static Coding tokenCoding8524_23[]; + static Coding tokenCoding8524_18[]; + static Coding tokenCoding8524_19[]; + void TokenFunc8524(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8529[]; + void TokenFunc8530(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8530[]; + static x64Token tokenBranches8531[]; + static Coding tokenCoding8532_16[]; + static Coding tokenCoding8532_17[]; + static Coding tokenCoding8532_23[]; + static Coding tokenCoding8532_18[]; + static Coding tokenCoding8532_19[]; + void TokenFunc8532(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8535[]; + void TokenFunc8536(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8536[]; + static x64Token tokenBranches8537[]; + static Coding tokenCoding8538_16[]; + static Coding tokenCoding8538_17[]; + static Coding tokenCoding8538_23[]; + static Coding tokenCoding8538_18[]; + static Coding tokenCoding8538_19[]; + void TokenFunc8538(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8543[]; + static x64Token tokenBranches8544[]; + static x64Token tokenBranches8545[]; + static Coding tokenCoding8546_16[]; + static Coding tokenCoding8546_17[]; + static Coding tokenCoding8546_23[]; + static Coding tokenCoding8546_18[]; + static Coding tokenCoding8546_19[]; + void TokenFunc8546(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8547[]; + static x64Token tokenBranches8548[]; + static x64Token tokenBranches8549[]; + static Coding tokenCoding8550_16[]; + static Coding tokenCoding8550_17[]; + static Coding tokenCoding8550_18[]; + void TokenFunc8550(x64Operand &operand, int tokenPos); + static Coding tokenCoding8553_16[]; + static Coding tokenCoding8553_17[]; + static Coding tokenCoding8553_18[]; + void TokenFunc8553(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8554[]; + static x64Token tokenBranches8555[]; + static x64Token tokenBranches8556[]; + static Coding tokenCoding8557_16[]; + static Coding tokenCoding8557_17[]; + static Coding tokenCoding8557_23[]; + static Coding tokenCoding8557_18[]; + static Coding tokenCoding8557_19[]; + void TokenFunc8557(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8558[]; + static x64Token tokenBranches8559[]; + static x64Token tokenBranches8560[]; + static Coding tokenCoding8561_16[]; + static Coding tokenCoding8561_17[]; + static Coding tokenCoding8561_23[]; + static Coding tokenCoding8561_18[]; + static Coding tokenCoding8561_19[]; + void TokenFunc8561(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8562[]; + static x64Token tokenBranches8563[]; + static x64Token tokenBranches8564[]; + static Coding tokenCoding8565_16[]; + static Coding tokenCoding8565_17[]; + static Coding tokenCoding8565_23[]; + static Coding tokenCoding8565_18[]; + static Coding tokenCoding8565_19[]; + void TokenFunc8565(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8566[]; + void TokenFunc8567(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8567[]; + static x64Token tokenBranches8568[]; + static Coding tokenCoding8569_16[]; + static Coding tokenCoding8569_17[]; + static Coding tokenCoding8569_23[]; + static Coding tokenCoding8569_18[]; + static Coding tokenCoding8569_19[]; + void TokenFunc8569(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8592[]; + void TokenFunc8593(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8593[]; + static x64Token tokenBranches8594[]; + static x64Token tokenBranches8595[]; + static x64Token tokenBranches8596[]; + static Coding tokenCoding8597_16[]; + static Coding tokenCoding8597_17[]; + static Coding tokenCoding8597_23[]; + static Coding tokenCoding8597_18[]; + void TokenFunc8597(x64Operand &operand, int tokenPos); + void TokenFunc8598(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8598[]; + static x64Token tokenBranches8599[]; + static x64Token tokenBranches8600[]; + static x64Token tokenBranches8601[]; + static Coding tokenCoding8602_16[]; + static Coding tokenCoding8602_17[]; + static Coding tokenCoding8602_23[]; + static Coding tokenCoding8602_18[]; + void TokenFunc8602(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8616[]; + static x64Token tokenBranches8617[]; + static x64Token tokenBranches8618[]; + void TokenFunc8619(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8619[]; + static x64Token tokenBranches8620[]; + static Coding tokenCoding8621_16[]; + static Coding tokenCoding8621_17[]; + static Coding tokenCoding8621_23[]; + static Coding tokenCoding8621_18[]; + void TokenFunc8621(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8622[]; + static x64Token tokenBranches8623[]; + static x64Token tokenBranches8624[]; + void TokenFunc8625(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8625[]; + static x64Token tokenBranches8626[]; + static Coding tokenCoding8627_16[]; + static Coding tokenCoding8627_17[]; + static Coding tokenCoding8627_23[]; + static Coding tokenCoding8627_18[]; + void TokenFunc8627(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8628[]; + static x64Token tokenBranches8629[]; + static x64Token tokenBranches8630[]; + void TokenFunc8631(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8631[]; + static x64Token tokenBranches8632[]; + static Coding tokenCoding8633_16[]; + static Coding tokenCoding8633_17[]; + static Coding tokenCoding8633_23[]; + static Coding tokenCoding8633_18[]; + void TokenFunc8633(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8634[]; + static x64Token tokenBranches8635[]; + static x64Token tokenBranches8636[]; + void TokenFunc8637(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8637[]; + static x64Token tokenBranches8638[]; + static Coding tokenCoding8639_16[]; + static Coding tokenCoding8639_17[]; + static Coding tokenCoding8639_23[]; + static Coding tokenCoding8639_18[]; + static Coding tokenCoding8639_19[]; + void TokenFunc8639(x64Operand &operand, int tokenPos); + void TokenFunc8640(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8640[]; + static x64Token tokenBranches8641[]; + static x64Token tokenBranches8642[]; + static x64Token tokenBranches8643[]; + static Coding tokenCoding8644_16[]; + static Coding tokenCoding8644_17[]; + static Coding tokenCoding8644_23[]; + static Coding tokenCoding8644_18[]; + static Coding tokenCoding8644_19[]; + void TokenFunc8644(x64Operand &operand, int tokenPos); + void TokenFunc8645(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8645[]; + static x64Token tokenBranches8646[]; + static x64Token tokenBranches8647[]; + static x64Token tokenBranches8648[]; + static Coding tokenCoding8649_16[]; + static Coding tokenCoding8649_17[]; + static Coding tokenCoding8649_23[]; + static Coding tokenCoding8649_18[]; + static Coding tokenCoding8649_19[]; + void TokenFunc8649(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8650[]; + static x64Token tokenBranches8651[]; + void TokenFunc8652(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8652[]; + static x64Token tokenBranches8653[]; + static Coding tokenCoding8654_16[]; + static Coding tokenCoding8654_17[]; + static Coding tokenCoding8654_23[]; + static Coding tokenCoding8654_18[]; + static Coding tokenCoding8654_19[]; + void TokenFunc8654(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8655[]; + void TokenFunc8656(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8656[]; + static x64Token tokenBranches8657[]; + static x64Token tokenBranches8658[]; + static x64Token tokenBranches8659[]; + static Coding tokenCoding8660_16[]; + static Coding tokenCoding8660_17[]; + static Coding tokenCoding8660_23[]; + static Coding tokenCoding8660_18[]; + void TokenFunc8660(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8661[]; + void TokenFunc8662(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8662[]; + static x64Token tokenBranches8663[]; + static x64Token tokenBranches8664[]; + static x64Token tokenBranches8665[]; + static Coding tokenCoding8666_16[]; + static Coding tokenCoding8666_17[]; + static Coding tokenCoding8666_23[]; + static Coding tokenCoding8666_18[]; + void TokenFunc8666(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8667[]; + void TokenFunc8668(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8668[]; + static x64Token tokenBranches8669[]; + static x64Token tokenBranches8670[]; + static x64Token tokenBranches8671[]; + static Coding tokenCoding8672_16[]; + static Coding tokenCoding8672_17[]; + static Coding tokenCoding8672_23[]; + static Coding tokenCoding8672_18[]; + void TokenFunc8672(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8673[]; + void TokenFunc8674(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8674[]; + static x64Token tokenBranches8675[]; + static x64Token tokenBranches8676[]; + static x64Token tokenBranches8677[]; + static Coding tokenCoding8678_16[]; + static Coding tokenCoding8678_17[]; + static Coding tokenCoding8678_23[]; + static Coding tokenCoding8678_18[]; + static Coding tokenCoding8678_19[]; + void TokenFunc8678(x64Operand &operand, int tokenPos); + void TokenFunc8679(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8679[]; + static x64Token tokenBranches8680[]; + static x64Token tokenBranches8681[]; + static x64Token tokenBranches8682[]; + static Coding tokenCoding8683_16[]; + static Coding tokenCoding8683_17[]; + static Coding tokenCoding8683_23[]; + static Coding tokenCoding8683_18[]; + static Coding tokenCoding8683_19[]; + void TokenFunc8683(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8686[]; + static x64Token tokenBranches8687[]; + static Coding tokenCoding8688_16[]; + static Coding tokenCoding8688_17[]; + static Coding tokenCoding8688_23[]; + static Coding tokenCoding8688_18[]; + static Coding tokenCoding8688_19[]; + void TokenFunc8688(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8691[]; + static x64Token tokenBranches8692[]; + static Coding tokenCoding8693_16[]; + static Coding tokenCoding8693_17[]; + static Coding tokenCoding8693_23[]; + static Coding tokenCoding8693_18[]; + static Coding tokenCoding8693_19[]; + void TokenFunc8693(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8699[]; + void TokenFunc8700(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8700[]; + static x64Token tokenBranches8701[]; + static Coding tokenCoding8702_16[]; + static Coding tokenCoding8702_17[]; + static Coding tokenCoding8702_23[]; + static Coding tokenCoding8702_18[]; + void TokenFunc8702(x64Operand &operand, int tokenPos); + void TokenFunc8703(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8703[]; + static x64Token tokenBranches8704[]; + static Coding tokenCoding8705_16[]; + static Coding tokenCoding8705_17[]; + static Coding tokenCoding8705_23[]; + static Coding tokenCoding8705_18[]; + void TokenFunc8705(x64Operand &operand, int tokenPos); + static Coding tokenCoding8708_16[]; + static Coding tokenCoding8708_17[]; + static Coding tokenCoding8708_23[]; + static Coding tokenCoding8708_18[]; + void TokenFunc8708(x64Operand &operand, int tokenPos); + static Coding tokenCoding8711_16[]; + static Coding tokenCoding8711_17[]; + static Coding tokenCoding8711_23[]; + static Coding tokenCoding8711_18[]; + void TokenFunc8711(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8720[]; + void TokenFunc8721(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8721[]; + static x64Token tokenBranches8722[]; + static x64Token tokenBranches8723[]; + static x64Token tokenBranches8724[]; + static Coding tokenCoding8725_16[]; + static Coding tokenCoding8725_17[]; + static Coding tokenCoding8725_18[]; + void TokenFunc8725(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8727[]; + static x64Token tokenBranches8728[]; + static x64Token tokenBranches8729[]; + static Coding tokenCoding8730_16[]; + static Coding tokenCoding8730_17[]; + static Coding tokenCoding8730_18[]; + void TokenFunc8730(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8736[]; + static x64Token tokenBranches8737[]; + static x64Token tokenBranches8738[]; + static Coding tokenCoding8739_16[]; + static Coding tokenCoding8739_17[]; + static Coding tokenCoding8739_18[]; + void TokenFunc8739(x64Operand &operand, int tokenPos); - asmError Opcode0(x64Operand& operand); - asmError Opcode1(x64Operand& operand); - asmError Opcode2(x64Operand& operand); - asmError Opcode3(x64Operand& operand); - asmError Opcode4(x64Operand& operand); - asmError Opcode5(x64Operand& operand); - asmError Opcode6(x64Operand& operand); - asmError Opcode7(x64Operand& operand); - asmError Opcode8(x64Operand& operand); - asmError Opcode9(x64Operand& operand); - asmError Opcode10(x64Operand& operand); - asmError Opcode11(x64Operand& operand); - asmError Opcode12(x64Operand& operand); - asmError Opcode13(x64Operand& operand); - asmError Opcode14(x64Operand& operand); - asmError Opcode15(x64Operand& operand); - asmError Opcode16(x64Operand& operand); - asmError Opcode17(x64Operand& operand); - asmError Opcode18(x64Operand& operand); - asmError Opcode19(x64Operand& operand); - asmError Opcode20(x64Operand& operand); - asmError Opcode21(x64Operand& operand); - asmError Opcode22(x64Operand& operand); - asmError Opcode23(x64Operand& operand); - asmError Opcode24(x64Operand& operand); - asmError Opcode25(x64Operand& operand); - asmError Opcode26(x64Operand& operand); - asmError Opcode27(x64Operand& operand); - asmError Opcode28(x64Operand& operand); - asmError Opcode29(x64Operand& operand); - asmError Opcode30(x64Operand& operand); - asmError Opcode31(x64Operand& operand); - static Coding OpcodeCodings32_19[]; - asmError Opcode32(x64Operand& operand); - static Coding OpcodeCodings33_19[]; - asmError Opcode33(x64Operand& operand); - static Coding OpcodeCodings34_19[]; - asmError Opcode34(x64Operand& operand); - static Coding OpcodeCodings35_19[]; - asmError Opcode35(x64Operand& operand); - static Coding OpcodeCodings36_18[]; - static Coding OpcodeCodings36_36[]; - static Coding OpcodeCodings36_37[]; - asmError Opcode36(x64Operand& operand); - static Coding OpcodeCodings37_18[]; - static Coding OpcodeCodings37_36[]; - static Coding OpcodeCodings37_37[]; - asmError Opcode37(x64Operand& operand); - static Coding OpcodeCodings38_18[]; - static Coding OpcodeCodings38_36[]; - static Coding OpcodeCodings38_37[]; - asmError Opcode38(x64Operand& operand); - asmError Opcode39(x64Operand& operand); - static Coding OpcodeCodings40_36[]; - asmError Opcode40(x64Operand& operand); - static Coding OpcodeCodings41_36[]; - asmError Opcode41(x64Operand& operand); - static Coding OpcodeCodings42_36[]; - asmError Opcode42(x64Operand& operand); - asmError Opcode43(x64Operand& operand); - static Coding OpcodeCodings44_18[]; - static Coding OpcodeCodings44_36[]; - static Coding OpcodeCodings44_37[]; - asmError Opcode44(x64Operand& operand); - static Coding OpcodeCodings45_18[]; - static Coding OpcodeCodings45_36[]; - static Coding OpcodeCodings45_37[]; - asmError Opcode45(x64Operand& operand); - static Coding OpcodeCodings46_18[]; - static Coding OpcodeCodings46_36[]; - static Coding OpcodeCodings46_37[]; - asmError Opcode46(x64Operand& operand); - static Coding OpcodeCodings47_18[]; - static Coding OpcodeCodings47_36[]; - static Coding OpcodeCodings47_37[]; - asmError Opcode47(x64Operand& operand); - asmError Opcode48(x64Operand& operand); - static Coding OpcodeCodings49_19[]; - asmError Opcode49(x64Operand& operand); - static Coding OpcodeCodings50_19[]; - asmError Opcode50(x64Operand& operand); - asmError Opcode51(x64Operand& operand); - static Coding OpcodeCodings52_19[]; - asmError Opcode52(x64Operand& operand); - static Coding OpcodeCodings53_19[]; - asmError Opcode53(x64Operand& operand); - static Coding OpcodeCodings54_19[]; - asmError Opcode54(x64Operand& operand); - static Coding OpcodeCodings55_19[]; - asmError Opcode55(x64Operand& operand); - static Coding OpcodeCodings56_19[]; - asmError Opcode56(x64Operand& operand); - static Coding OpcodeCodings57_38[]; - asmError Opcode57(x64Operand& operand); - static Coding OpcodeCodings58_38[]; - asmError Opcode58(x64Operand& operand); - static Coding OpcodeCodings59_38[]; - asmError Opcode59(x64Operand& operand); - static Coding OpcodeCodings60_38[]; - asmError Opcode60(x64Operand& operand); - static Coding OpcodeCodings61_38[]; - asmError Opcode61(x64Operand& operand); - static Coding OpcodeCodings62_38[]; - asmError Opcode62(x64Operand& operand); - static Coding OpcodeCodings63_38[]; - asmError Opcode63(x64Operand& operand); - static Coding OpcodeCodings64_38[]; - asmError Opcode64(x64Operand& operand); - static Coding OpcodeCodings65_38[]; - asmError Opcode65(x64Operand& operand); - static Coding OpcodeCodings66_38[]; - asmError Opcode66(x64Operand& operand); - static Coding OpcodeCodings67_38[]; - asmError Opcode67(x64Operand& operand); - static Coding OpcodeCodings68_38[]; - asmError Opcode68(x64Operand& operand); - static Coding OpcodeCodings69_38[]; - asmError Opcode69(x64Operand& operand); - static Coding OpcodeCodings70_38[]; - asmError Opcode70(x64Operand& operand); - static Coding OpcodeCodings71_38[]; - asmError Opcode71(x64Operand& operand); - static Coding OpcodeCodings72_38[]; - asmError Opcode72(x64Operand& operand); - static Coding OpcodeCodings73_38[]; - asmError Opcode73(x64Operand& operand); - static Coding OpcodeCodings74_38[]; - asmError Opcode74(x64Operand& operand); - static Coding OpcodeCodings75_38[]; - asmError Opcode75(x64Operand& operand); - static Coding OpcodeCodings76_38[]; - asmError Opcode76(x64Operand& operand); - static Coding OpcodeCodings77_38[]; - asmError Opcode77(x64Operand& operand); - static Coding OpcodeCodings78_38[]; - asmError Opcode78(x64Operand& operand); - static Coding OpcodeCodings79_38[]; - asmError Opcode79(x64Operand& operand); - static Coding OpcodeCodings80_38[]; - asmError Opcode80(x64Operand& operand); - static Coding OpcodeCodings81_38[]; - asmError Opcode81(x64Operand& operand); - static Coding OpcodeCodings82_38[]; - asmError Opcode82(x64Operand& operand); - static Coding OpcodeCodings83_38[]; - asmError Opcode83(x64Operand& operand); - static Coding OpcodeCodings84_38[]; - asmError Opcode84(x64Operand& operand); - static Coding OpcodeCodings85_38[]; - asmError Opcode85(x64Operand& operand); - static Coding OpcodeCodings86_38[]; - asmError Opcode86(x64Operand& operand); - static Coding OpcodeCodings87_18[]; - static Coding OpcodeCodings87_36[]; - static Coding OpcodeCodings87_37[]; - asmError Opcode87(x64Operand& operand); - asmError Opcode88(x64Operand& operand); - static Coding OpcodeCodings89_19[]; - asmError Opcode89(x64Operand& operand); - static Coding OpcodeCodings90_19[]; - asmError Opcode90(x64Operand& operand); - static Coding OpcodeCodings91_19[]; - asmError Opcode91(x64Operand& operand); - asmError Opcode92(x64Operand& operand); - static Coding OpcodeCodings93_36[]; - asmError Opcode93(x64Operand& operand); - asmError Opcode94(x64Operand& operand); - asmError Opcode95(x64Operand& operand); - static Coding OpcodeCodings96_19[]; - asmError Opcode96(x64Operand& operand); - asmError Opcode97(x64Operand& operand); - static Coding OpcodeCodings98_19[]; - asmError Opcode98(x64Operand& operand); - static Coding OpcodeCodings99_19[]; - asmError Opcode99(x64Operand& operand); - static Coding OpcodeCodings100_19[]; - asmError Opcode100(x64Operand& operand); - static Coding OpcodeCodings101_19[]; - asmError Opcode101(x64Operand& operand); - static Coding OpcodeCodings102_18[]; - static Coding OpcodeCodings102_19[]; - asmError Opcode102(x64Operand& operand); - static Coding OpcodeCodings103_18[]; - asmError Opcode103(x64Operand& operand); - asmError Opcode104(x64Operand& operand); - asmError Opcode105(x64Operand& operand); - static Coding OpcodeCodings106_19[]; - asmError Opcode106(x64Operand& operand); - static Coding OpcodeCodings107_19[]; - asmError Opcode107(x64Operand& operand); - static Coding OpcodeCodings108_18[]; - static Coding OpcodeCodings108_39[]; - static Coding OpcodeCodings108_36[]; - asmError Opcode108(x64Operand& operand); - static Coding OpcodeCodings109_18[]; - static Coding OpcodeCodings109_19[]; - asmError Opcode109(x64Operand& operand); - static Coding OpcodeCodings110_18[]; - static Coding OpcodeCodings110_19[]; - asmError Opcode110(x64Operand& operand); - static Coding OpcodeCodings111_18[]; - static Coding OpcodeCodings111_19[]; - asmError Opcode111(x64Operand& operand); - static Coding OpcodeCodings112_19[]; - asmError Opcode112(x64Operand& operand); - static Coding OpcodeCodings113_19[]; - asmError Opcode113(x64Operand& operand); - static Coding OpcodeCodings114_19[]; - asmError Opcode114(x64Operand& operand); - static Coding OpcodeCodings115_18[]; - static Coding OpcodeCodings115_36[]; - asmError Opcode115(x64Operand& operand); - static Coding OpcodeCodings116_18[]; - static Coding OpcodeCodings116_36[]; - asmError Opcode116(x64Operand& operand); - static Coding OpcodeCodings117_18[]; - static Coding OpcodeCodings117_36[]; - asmError Opcode117(x64Operand& operand); - static Coding OpcodeCodings118_18[]; - static Coding OpcodeCodings118_36[]; - asmError Opcode118(x64Operand& operand); - static Coding OpcodeCodings119_18[]; - static Coding OpcodeCodings119_36[]; - asmError Opcode119(x64Operand& operand); - static Coding OpcodeCodings120_18[]; - static Coding OpcodeCodings120_36[]; - asmError Opcode120(x64Operand& operand); - static Coding OpcodeCodings121_18[]; - static Coding OpcodeCodings121_36[]; - asmError Opcode121(x64Operand& operand); - static Coding OpcodeCodings122_18[]; - static Coding OpcodeCodings122_36[]; - asmError Opcode122(x64Operand& operand); - static Coding OpcodeCodings123_18[]; - static Coding OpcodeCodings123_36[]; - asmError Opcode123(x64Operand& operand); - static Coding OpcodeCodings124_18[]; - static Coding OpcodeCodings124_36[]; - asmError Opcode124(x64Operand& operand); - static Coding OpcodeCodings125_18[]; - static Coding OpcodeCodings125_36[]; - asmError Opcode125(x64Operand& operand); - static Coding OpcodeCodings126_18[]; - static Coding OpcodeCodings126_36[]; - asmError Opcode126(x64Operand& operand); - static Coding OpcodeCodings127_19[]; - asmError Opcode127(x64Operand& operand); - static Coding OpcodeCodings128_19[]; - asmError Opcode128(x64Operand& operand); - static Coding OpcodeCodings129_19[]; - asmError Opcode129(x64Operand& operand); - static Coding OpcodeCodings130_19[]; - asmError Opcode130(x64Operand& operand); - static Coding OpcodeCodings131_18[]; - static Coding OpcodeCodings131_39[]; - static Coding OpcodeCodings131_36[]; - asmError Opcode131(x64Operand& operand); - static Coding OpcodeCodings132_18[]; - static Coding OpcodeCodings132_19[]; - asmError Opcode132(x64Operand& operand); - static Coding OpcodeCodings133_18[]; - static Coding OpcodeCodings133_39[]; - static Coding OpcodeCodings133_36[]; - asmError Opcode133(x64Operand& operand); - static Coding OpcodeCodings134_18[]; - static Coding OpcodeCodings134_19[]; - asmError Opcode134(x64Operand& operand); - static Coding OpcodeCodings135_19[]; - asmError Opcode135(x64Operand& operand); - asmError Opcode136(x64Operand& operand); - asmError Opcode137(x64Operand& operand); - static Coding OpcodeCodings138_18[]; - static Coding OpcodeCodings138_36[]; - asmError Opcode138(x64Operand& operand); - static Coding OpcodeCodings139_18[]; - static Coding OpcodeCodings139_36[]; - asmError Opcode139(x64Operand& operand); - static Coding OpcodeCodings140_18[]; - static Coding OpcodeCodings140_36[]; - asmError Opcode140(x64Operand& operand); - static Coding OpcodeCodings141_18[]; - static Coding OpcodeCodings141_36[]; - asmError Opcode141(x64Operand& operand); - static Coding OpcodeCodings142_18[]; - static Coding OpcodeCodings142_36[]; - asmError Opcode142(x64Operand& operand); - static Coding OpcodeCodings143_18[]; - static Coding OpcodeCodings143_36[]; - asmError Opcode143(x64Operand& operand); - static Coding OpcodeCodings144_18[]; - static Coding OpcodeCodings144_36[]; - asmError Opcode144(x64Operand& operand); - static Coding OpcodeCodings145_19[]; - asmError Opcode145(x64Operand& operand); - static Coding OpcodeCodings146_19[]; - asmError Opcode146(x64Operand& operand); - static Coding OpcodeCodings147_19[]; - asmError Opcode147(x64Operand& operand); - static Coding OpcodeCodings148_18[]; - static Coding OpcodeCodings148_36[]; - asmError Opcode148(x64Operand& operand); - static Coding OpcodeCodings149_18[]; - static Coding OpcodeCodings149_36[]; - asmError Opcode149(x64Operand& operand); - static Coding OpcodeCodings150_18[]; - static Coding OpcodeCodings150_36[]; - asmError Opcode150(x64Operand& operand); - static Coding OpcodeCodings151_18[]; - static Coding OpcodeCodings151_36[]; - asmError Opcode151(x64Operand& operand); - asmError Opcode152(x64Operand& operand); - static Coding OpcodeCodings153_19[]; - asmError Opcode153(x64Operand& operand); - asmError Opcode154(x64Operand& operand); - asmError Opcode155(x64Operand& operand); - static Coding OpcodeCodings156_19[]; - asmError Opcode156(x64Operand& operand); - static Coding OpcodeCodings157_19[]; - asmError Opcode157(x64Operand& operand); - static Coding OpcodeCodings158_19[]; - asmError Opcode158(x64Operand& operand); - static Coding OpcodeCodings159_19[]; - asmError Opcode159(x64Operand& operand); - static Coding OpcodeCodings160_19[]; - asmError Opcode160(x64Operand& operand); - static Coding OpcodeCodings161_19[]; - asmError Opcode161(x64Operand& operand); - static Coding OpcodeCodings162_18[]; - static Coding OpcodeCodings162_39[]; - static Coding OpcodeCodings162_36[]; - asmError Opcode162(x64Operand& operand); - static Coding OpcodeCodings163_18[]; - static Coding OpcodeCodings163_19[]; - asmError Opcode163(x64Operand& operand); - static Coding OpcodeCodings164_19[]; - asmError Opcode164(x64Operand& operand); - asmError Opcode165(x64Operand& operand); - static Coding OpcodeCodings166_19[]; - asmError Opcode166(x64Operand& operand); - static Coding OpcodeCodings167_19[]; - asmError Opcode167(x64Operand& operand); - static Coding OpcodeCodings168_19[]; - asmError Opcode168(x64Operand& operand); - static Coding OpcodeCodings169_19[]; - asmError Opcode169(x64Operand& operand); - static Coding OpcodeCodings170_19[]; - asmError Opcode170(x64Operand& operand); - asmError Opcode171(x64Operand& operand); - asmError Opcode172(x64Operand& operand); - static Coding OpcodeCodings173_19[]; - asmError Opcode173(x64Operand& operand); - static Coding OpcodeCodings174_19[]; - asmError Opcode174(x64Operand& operand); - static Coding OpcodeCodings175_19[]; - asmError Opcode175(x64Operand& operand); - static Coding OpcodeCodings176_19[]; - asmError Opcode176(x64Operand& operand); - static Coding OpcodeCodings177_19[]; - asmError Opcode177(x64Operand& operand); - asmError Opcode178(x64Operand& operand); - asmError Opcode179(x64Operand& operand); - asmError Opcode180(x64Operand& operand); - asmError Opcode181(x64Operand& operand); - asmError Opcode182(x64Operand& operand); - asmError Opcode183(x64Operand& operand); - asmError Opcode184(x64Operand& operand); - asmError Opcode185(x64Operand& operand); - static Coding OpcodeCodings186_18[]; - static Coding OpcodeCodings186_39[]; - static Coding OpcodeCodings186_36[]; - asmError Opcode186(x64Operand& operand); - static Coding OpcodeCodings187_18[]; - static Coding OpcodeCodings187_19[]; - asmError Opcode187(x64Operand& operand); - static Coding OpcodeCodings188_18[]; - static Coding OpcodeCodings188_39[]; - static Coding OpcodeCodings188_36[]; - asmError Opcode188(x64Operand& operand); - static Coding OpcodeCodings189_18[]; - static Coding OpcodeCodings189_19[]; - asmError Opcode189(x64Operand& operand); - static Coding OpcodeCodings190_19[]; - asmError Opcode190(x64Operand& operand); - static Coding OpcodeCodings191_18[]; - static Coding OpcodeCodings191_19[]; - asmError Opcode191(x64Operand& operand); - static Coding OpcodeCodings192_18[]; - static Coding OpcodeCodings192_36[]; - asmError Opcode192(x64Operand& operand); - static Coding OpcodeCodings193_18[]; - static Coding OpcodeCodings193_36[]; - asmError Opcode193(x64Operand& operand); - static Coding OpcodeCodings194_18[]; - static Coding OpcodeCodings194_19[]; - asmError Opcode194(x64Operand& operand); - static Coding OpcodeCodings195_19[]; - asmError Opcode195(x64Operand& operand); - static Coding OpcodeCodings196_19[]; - asmError Opcode196(x64Operand& operand); - static Coding OpcodeCodings197_19[]; - asmError Opcode197(x64Operand& operand); - static Coding OpcodeCodings198_18[]; - static Coding OpcodeCodings198_19[]; - asmError Opcode198(x64Operand& operand); - static Coding OpcodeCodings199_18[]; - static Coding OpcodeCodings199_36[]; - asmError Opcode199(x64Operand& operand); - static Coding OpcodeCodings200_18[]; - static Coding OpcodeCodings200_36[]; - asmError Opcode200(x64Operand& operand); - asmError Opcode201(x64Operand& operand); - asmError Opcode202(x64Operand& operand); - static Coding OpcodeCodings203_19[]; - asmError Opcode203(x64Operand& operand); - static Coding OpcodeCodings204_19[]; - asmError Opcode204(x64Operand& operand); - static Coding OpcodeCodings205_19[]; - asmError Opcode205(x64Operand& operand); - static Coding OpcodeCodings206_19[]; - asmError Opcode206(x64Operand& operand); - static Coding OpcodeCodings207_19[]; - asmError Opcode207(x64Operand& operand); - static Coding OpcodeCodings208_18[]; - asmError Opcode208(x64Operand& operand); - asmError Opcode209(x64Operand& operand); - asmError Opcode210(x64Operand& operand); - asmError Opcode211(x64Operand& operand); - static Coding OpcodeCodings212_19[]; - asmError Opcode212(x64Operand& operand); - static Coding OpcodeCodings213_19[]; - asmError Opcode213(x64Operand& operand); - static Coding OpcodeCodings214_19[]; - asmError Opcode214(x64Operand& operand); - static Coding OpcodeCodings215_18[]; - static Coding OpcodeCodings215_19[]; - asmError Opcode215(x64Operand& operand); - asmError Opcode216(x64Operand& operand); - static Coding OpcodeCodings217_19[]; - asmError Opcode217(x64Operand& operand); - static Coding OpcodeCodings218_19[]; - asmError Opcode218(x64Operand& operand); - static Coding OpcodeCodings219_19[]; - asmError Opcode219(x64Operand& operand); - static Coding OpcodeCodings220_19[]; - asmError Opcode220(x64Operand& operand); - asmError Opcode221(x64Operand& operand); - static Coding OpcodeCodings222_19[]; - asmError Opcode222(x64Operand& operand); - static Coding OpcodeCodings223_19[]; - asmError Opcode223(x64Operand& operand); - asmError Opcode224(x64Operand& operand); - static Coding OpcodeCodings225_19[]; - asmError Opcode225(x64Operand& operand); - static Coding OpcodeCodings226_38[]; - asmError Opcode226(x64Operand& operand); - static Coding OpcodeCodings227_38[]; - asmError Opcode227(x64Operand& operand); - static Coding OpcodeCodings228_38[]; - asmError Opcode228(x64Operand& operand); - static Coding OpcodeCodings229_38[]; - asmError Opcode229(x64Operand& operand); - static Coding OpcodeCodings230_38[]; - asmError Opcode230(x64Operand& operand); - asmError Opcode231(x64Operand& operand); - asmError Opcode232(x64Operand& operand); - static Coding OpcodeCodings233_38[]; - asmError Opcode233(x64Operand& operand); - static Coding OpcodeCodings234_38[]; - asmError Opcode234(x64Operand& operand); - static Coding OpcodeCodings235_38[]; - asmError Opcode235(x64Operand& operand); - static Coding OpcodeCodings236_38[]; - asmError Opcode236(x64Operand& operand); - static Coding OpcodeCodings237_38[]; - asmError Opcode237(x64Operand& operand); - asmError Opcode238(x64Operand& operand); - static Coding OpcodeCodings239_38[]; - asmError Opcode239(x64Operand& operand); - static Coding OpcodeCodings240_38[]; - asmError Opcode240(x64Operand& operand); - static Coding OpcodeCodings241_38[]; - asmError Opcode241(x64Operand& operand); - static Coding OpcodeCodings242_38[]; - asmError Opcode242(x64Operand& operand); - static Coding OpcodeCodings243_38[]; - asmError Opcode243(x64Operand& operand); - static Coding OpcodeCodings244_38[]; - asmError Opcode244(x64Operand& operand); - static Coding OpcodeCodings245_38[]; - asmError Opcode245(x64Operand& operand); - static Coding OpcodeCodings246_38[]; - asmError Opcode246(x64Operand& operand); - static Coding OpcodeCodings247_38[]; - asmError Opcode247(x64Operand& operand); - static Coding OpcodeCodings248_38[]; - asmError Opcode248(x64Operand& operand); - static Coding OpcodeCodings249_38[]; - asmError Opcode249(x64Operand& operand); - static Coding OpcodeCodings250_38[]; - asmError Opcode250(x64Operand& operand); - static Coding OpcodeCodings251_38[]; - asmError Opcode251(x64Operand& operand); - static Coding OpcodeCodings252_38[]; - asmError Opcode252(x64Operand& operand); - static Coding OpcodeCodings253_38[]; - asmError Opcode253(x64Operand& operand); - static Coding OpcodeCodings254_38[]; - asmError Opcode254(x64Operand& operand); - static Coding OpcodeCodings255_38[]; - asmError Opcode255(x64Operand& operand); - static Coding OpcodeCodings256_38[]; - asmError Opcode256(x64Operand& operand); - static Coding OpcodeCodings257_38[]; - asmError Opcode257(x64Operand& operand); - static Coding OpcodeCodings258_38[]; - asmError Opcode258(x64Operand& operand); - static Coding OpcodeCodings259_19[]; - asmError Opcode259(x64Operand& operand); - static Coding OpcodeCodings260_36[]; - asmError Opcode260(x64Operand& operand); - static Coding OpcodeCodings261_36[]; - asmError Opcode261(x64Operand& operand); - static Coding OpcodeCodings262_36[]; - asmError Opcode262(x64Operand& operand); - static Coding OpcodeCodings263_19[]; - asmError Opcode263(x64Operand& operand); - static Coding OpcodeCodings264_36[]; - asmError Opcode264(x64Operand& operand); - static Coding OpcodeCodings265_19[]; - asmError Opcode265(x64Operand& operand); - static Coding OpcodeCodings266_36[]; - asmError Opcode266(x64Operand& operand); - static Coding OpcodeCodings267_18[]; - static Coding OpcodeCodings267_19[]; - asmError Opcode267(x64Operand& operand); - static Coding OpcodeCodings268_36[]; - asmError Opcode268(x64Operand& operand); - static Coding OpcodeCodings269_18[]; - static Coding OpcodeCodings269_19[]; - asmError Opcode269(x64Operand& operand); - static Coding OpcodeCodings270_18[]; - static Coding OpcodeCodings270_19[]; - asmError Opcode270(x64Operand& operand); - static Coding OpcodeCodings271_18[]; - static Coding OpcodeCodings271_19[]; - asmError Opcode271(x64Operand& operand); - asmError Opcode272(x64Operand& operand); - static Coding OpcodeCodings273_19[]; - asmError Opcode273(x64Operand& operand); - static Coding OpcodeCodings274_19[]; - asmError Opcode274(x64Operand& operand); - static Coding OpcodeCodings275_19[]; - asmError Opcode275(x64Operand& operand); - asmError Opcode276(x64Operand& operand); - asmError Opcode277(x64Operand& operand); - asmError Opcode278(x64Operand& operand); - asmError Opcode279(x64Operand& operand); - asmError Opcode280(x64Operand& operand); - asmError Opcode281(x64Operand& operand); - static Coding OpcodeCodings282_36[]; - asmError Opcode282(x64Operand& operand); - static Coding OpcodeCodings283_36[]; - asmError Opcode283(x64Operand& operand); - static Coding OpcodeCodings284_18[]; - static Coding OpcodeCodings284_19[]; - asmError Opcode284(x64Operand& operand); - asmError Opcode285(x64Operand& operand); - asmError Opcode286(x64Operand& operand); - static Coding OpcodeCodings287_36[]; - asmError Opcode287(x64Operand& operand); - static Coding OpcodeCodings288_19[]; - asmError Opcode288(x64Operand& operand); - static Coding OpcodeCodings289_19[]; - asmError Opcode289(x64Operand& operand); - asmError Opcode290(x64Operand& operand); - asmError Opcode291(x64Operand& operand); - static Coding OpcodeCodings292_36[]; - asmError Opcode292(x64Operand& operand); - static Coding OpcodeCodings293_36[]; - asmError Opcode293(x64Operand& operand); - asmError Opcode294(x64Operand& operand); - static Coding OpcodeCodings295_18[]; - asmError Opcode295(x64Operand& operand); - static Coding OpcodeCodings296_18[]; - asmError Opcode296(x64Operand& operand); - static Coding OpcodeCodings297_19[]; - asmError Opcode297(x64Operand& operand); - static Coding OpcodeCodings298_18[]; - asmError Opcode298(x64Operand& operand); - static Coding OpcodeCodings299_18[]; - static Coding OpcodeCodings299_36[]; - static Coding OpcodeCodings299_37[]; - asmError Opcode299(x64Operand& operand); - asmError Opcode300(x64Operand& operand); - asmError Opcode301(x64Operand& operand); - static Coding OpcodeCodings302_19[]; - asmError Opcode302(x64Operand& operand); - static Coding OpcodeCodings303_19[]; - asmError Opcode303(x64Operand& operand); - static Coding OpcodeCodings304_19[]; - asmError Opcode304(x64Operand& operand); - asmError Opcode305(x64Operand& operand); - static Coding OpcodeCodings306_19[]; - asmError Opcode306(x64Operand& operand); - static Coding OpcodeCodings307_19[]; - asmError Opcode307(x64Operand& operand); - static Coding OpcodeCodings308_19[]; - asmError Opcode308(x64Operand& operand); - static Coding OpcodeCodings309_23[]; - static Coding OpcodeCodings309_36[]; - asmError Opcode309(x64Operand& operand); - static Coding OpcodeCodings310_19[]; - asmError Opcode310(x64Operand& operand); - static Coding OpcodeCodings311_19[]; - asmError Opcode311(x64Operand& operand); - static Coding OpcodeCodings312_19[]; - asmError Opcode312(x64Operand& operand); - static Coding OpcodeCodings313_19[]; - asmError Opcode313(x64Operand& operand); - asmError Opcode314(x64Operand& operand); - asmError Opcode315(x64Operand& operand); - asmError Opcode316(x64Operand& operand); - asmError Opcode317(x64Operand& operand); - asmError Opcode318(x64Operand& operand); - static Coding OpcodeCodings319_19[]; - asmError Opcode319(x64Operand& operand); - static Coding OpcodeCodings320_19[]; - asmError Opcode320(x64Operand& operand); - static Coding OpcodeCodings321_19[]; - asmError Opcode321(x64Operand& operand); - static Coding OpcodeCodings322_19[]; - asmError Opcode322(x64Operand& operand); - static Coding OpcodeCodings323_19[]; - asmError Opcode323(x64Operand& operand); - static Coding OpcodeCodings324_19[]; - asmError Opcode324(x64Operand& operand); - static Coding OpcodeCodings325_19[]; - asmError Opcode325(x64Operand& operand); - static Coding OpcodeCodings326_18[]; - asmError Opcode326(x64Operand& operand); - static Coding OpcodeCodings327_18[]; - asmError Opcode327(x64Operand& operand); - static Coding OpcodeCodings328_19[]; - asmError Opcode328(x64Operand& operand); - static Coding OpcodeCodings329_19[]; - asmError Opcode329(x64Operand& operand); - static Coding OpcodeCodings330_19[]; - asmError Opcode330(x64Operand& operand); - asmError Opcode331(x64Operand& operand); - asmError Opcode332(x64Operand& operand); - static Coding OpcodeCodings333_18[]; - asmError Opcode333(x64Operand& operand); - static Coding OpcodeCodings334_18[]; - asmError Opcode334(x64Operand& operand); - static Coding OpcodeCodings335_19[]; - asmError Opcode335(x64Operand& operand); - static Coding OpcodeCodings336_19[]; - asmError Opcode336(x64Operand& operand); - static Coding OpcodeCodings337_18[]; - asmError Opcode337(x64Operand& operand); - static Coding OpcodeCodings338_18[]; - asmError Opcode338(x64Operand& operand); - static Coding OpcodeCodings339_18[]; - static Coding OpcodeCodings339_36[]; - static Coding OpcodeCodings339_37[]; - asmError Opcode339(x64Operand& operand); - asmError Opcode340(x64Operand& operand); - static Coding OpcodeCodings341_19[]; - asmError Opcode341(x64Operand& operand); - static Coding OpcodeCodings342_19[]; - asmError Opcode342(x64Operand& operand); - static Coding OpcodeCodings343_19[]; - asmError Opcode343(x64Operand& operand); - asmError Opcode344(x64Operand& operand); - static Coding OpcodeCodings345_38[]; - asmError Opcode345(x64Operand& operand); - static Coding OpcodeCodings346_38[]; - asmError Opcode346(x64Operand& operand); - static Coding OpcodeCodings347_38[]; - asmError Opcode347(x64Operand& operand); - static Coding OpcodeCodings348_38[]; - asmError Opcode348(x64Operand& operand); - static Coding OpcodeCodings349_38[]; - asmError Opcode349(x64Operand& operand); - static Coding OpcodeCodings350_38[]; - asmError Opcode350(x64Operand& operand); - static Coding OpcodeCodings351_38[]; - asmError Opcode351(x64Operand& operand); - static Coding OpcodeCodings352_38[]; - asmError Opcode352(x64Operand& operand); - static Coding OpcodeCodings353_38[]; - asmError Opcode353(x64Operand& operand); - static Coding OpcodeCodings354_38[]; - asmError Opcode354(x64Operand& operand); - static Coding OpcodeCodings355_38[]; - asmError Opcode355(x64Operand& operand); - static Coding OpcodeCodings356_38[]; - asmError Opcode356(x64Operand& operand); - static Coding OpcodeCodings357_38[]; - asmError Opcode357(x64Operand& operand); - static Coding OpcodeCodings358_38[]; - asmError Opcode358(x64Operand& operand); - static Coding OpcodeCodings359_38[]; - asmError Opcode359(x64Operand& operand); - static Coding OpcodeCodings360_38[]; - asmError Opcode360(x64Operand& operand); - static Coding OpcodeCodings361_38[]; - asmError Opcode361(x64Operand& operand); - static Coding OpcodeCodings362_38[]; - asmError Opcode362(x64Operand& operand); - static Coding OpcodeCodings363_38[]; - asmError Opcode363(x64Operand& operand); - static Coding OpcodeCodings364_38[]; - asmError Opcode364(x64Operand& operand); - static Coding OpcodeCodings365_38[]; - asmError Opcode365(x64Operand& operand); - static Coding OpcodeCodings366_38[]; - asmError Opcode366(x64Operand& operand); - static Coding OpcodeCodings367_38[]; - asmError Opcode367(x64Operand& operand); - static Coding OpcodeCodings368_38[]; - asmError Opcode368(x64Operand& operand); - static Coding OpcodeCodings369_38[]; - asmError Opcode369(x64Operand& operand); - static Coding OpcodeCodings370_38[]; - asmError Opcode370(x64Operand& operand); - static Coding OpcodeCodings371_38[]; - asmError Opcode371(x64Operand& operand); - static Coding OpcodeCodings372_38[]; - asmError Opcode372(x64Operand& operand); - static Coding OpcodeCodings373_38[]; - asmError Opcode373(x64Operand& operand); - static Coding OpcodeCodings374_38[]; - asmError Opcode374(x64Operand& operand); - static Coding OpcodeCodings375_19[]; - asmError Opcode375(x64Operand& operand); - static Coding OpcodeCodings376_18[]; - static Coding OpcodeCodings376_19[]; - asmError Opcode376(x64Operand& operand); - static Coding OpcodeCodings377_18[]; - asmError Opcode377(x64Operand& operand); - static Coding OpcodeCodings378_36[]; - asmError Opcode378(x64Operand& operand); - static Coding OpcodeCodings379_18[]; - asmError Opcode379(x64Operand& operand); - static Coding OpcodeCodings380_36[]; - asmError Opcode380(x64Operand& operand); - static Coding OpcodeCodings381_18[]; - static Coding OpcodeCodings381_19[]; - asmError Opcode381(x64Operand& operand); - static Coding OpcodeCodings382_18[]; - static Coding OpcodeCodings382_19[]; - asmError Opcode382(x64Operand& operand); - static Coding OpcodeCodings383_18[]; - static Coding OpcodeCodings383_19[]; - asmError Opcode383(x64Operand& operand); - static Coding OpcodeCodings384_19[]; - asmError Opcode384(x64Operand& operand); - static Coding OpcodeCodings385_19[]; - asmError Opcode385(x64Operand& operand); - static Coding OpcodeCodings386_19[]; - asmError Opcode386(x64Operand& operand); - asmError Opcode387(x64Operand& operand); - static Coding OpcodeCodings388_19[]; - asmError Opcode388(x64Operand& operand); - static Coding OpcodeCodings389_19[]; - asmError Opcode389(x64Operand& operand); - static Coding OpcodeCodings390_19[]; - asmError Opcode390(x64Operand& operand); - asmError Opcode391(x64Operand& operand); - static Coding OpcodeCodings392_18[]; - static Coding OpcodeCodings392_19[]; - asmError Opcode392(x64Operand& operand); - static Coding OpcodeCodings393_18[]; - static Coding OpcodeCodings393_36[]; - static Coding OpcodeCodings393_37[]; - asmError Opcode393(x64Operand& operand); - static Coding OpcodeCodings394_19[]; - asmError Opcode394(x64Operand& operand); - static Coding OpcodeCodings395_19[]; - asmError Opcode395(x64Operand& operand); - static Coding OpcodeCodings396_19[]; - asmError Opcode396(x64Operand& operand); - static Coding OpcodeCodings397_19[]; - asmError Opcode397(x64Operand& operand); - asmError Opcode398(x64Operand& operand); - static Coding OpcodeCodings399_19[]; - asmError Opcode399(x64Operand& operand); - static Coding OpcodeCodings400_18[]; - static Coding OpcodeCodings400_19[]; - asmError Opcode400(x64Operand& operand); - static Coding OpcodeCodings401_18[]; - static Coding OpcodeCodings401_19[]; - asmError Opcode401(x64Operand& operand); - static Coding OpcodeCodings402_19[]; - asmError Opcode402(x64Operand& operand); - static Coding OpcodeCodings403_19[]; - asmError Opcode403(x64Operand& operand); - static Coding OpcodeCodings404_19[]; - asmError Opcode404(x64Operand& operand); - asmError Opcode405(x64Operand& operand); - asmError Opcode406(x64Operand& operand); - asmError Opcode407(x64Operand& operand); - static Coding OpcodeCodings408_19[]; - asmError Opcode408(x64Operand& operand); - static Coding OpcodeCodings409_18[]; - static Coding OpcodeCodings409_36[]; - static Coding OpcodeCodings409_37[]; - asmError Opcode409(x64Operand& operand); - asmError Opcode410(x64Operand& operand); - asmError Opcode411(x64Operand& operand); - asmError Opcode412(x64Operand& operand); - asmError Opcode413(x64Operand& operand); - static Coding OpcodeCodings414_19[]; - asmError Opcode414(x64Operand& operand); - static Coding OpcodeCodings415_23[]; - static Coding OpcodeCodings415_19[]; - asmError Opcode415(x64Operand& operand); - static Coding OpcodeCodings416_23[]; - static Coding OpcodeCodings416_19[]; - asmError Opcode416(x64Operand& operand); - static Coding OpcodeCodings417_23[]; - static Coding OpcodeCodings417_19[]; - asmError Opcode417(x64Operand& operand); - static Coding OpcodeCodings418_23[]; - static Coding OpcodeCodings418_19[]; - asmError Opcode418(x64Operand& operand); - static Coding OpcodeCodings419_23[]; - static Coding OpcodeCodings419_19[]; - asmError Opcode419(x64Operand& operand); - static Coding OpcodeCodings420_23[]; - static Coding OpcodeCodings420_19[]; - asmError Opcode420(x64Operand& operand); - static Coding OpcodeCodings421_23[]; - static Coding OpcodeCodings421_19[]; - asmError Opcode421(x64Operand& operand); - static Coding OpcodeCodings422_23[]; - static Coding OpcodeCodings422_19[]; - asmError Opcode422(x64Operand& operand); - static Coding OpcodeCodings423_23[]; - static Coding OpcodeCodings423_19[]; - asmError Opcode423(x64Operand& operand); - static Coding OpcodeCodings424_23[]; - static Coding OpcodeCodings424_19[]; - asmError Opcode424(x64Operand& operand); - static Coding OpcodeCodings425_23[]; - static Coding OpcodeCodings425_19[]; - asmError Opcode425(x64Operand& operand); - static Coding OpcodeCodings426_23[]; - static Coding OpcodeCodings426_19[]; - asmError Opcode426(x64Operand& operand); - static Coding OpcodeCodings427_23[]; - static Coding OpcodeCodings427_19[]; - asmError Opcode427(x64Operand& operand); - static Coding OpcodeCodings428_23[]; - static Coding OpcodeCodings428_19[]; - asmError Opcode428(x64Operand& operand); - static Coding OpcodeCodings429_23[]; - static Coding OpcodeCodings429_19[]; - asmError Opcode429(x64Operand& operand); - static Coding OpcodeCodings430_23[]; - static Coding OpcodeCodings430_19[]; - asmError Opcode430(x64Operand& operand); - static Coding OpcodeCodings431_23[]; - static Coding OpcodeCodings431_19[]; - asmError Opcode431(x64Operand& operand); - static Coding OpcodeCodings432_23[]; - static Coding OpcodeCodings432_19[]; - asmError Opcode432(x64Operand& operand); - static Coding OpcodeCodings433_23[]; - static Coding OpcodeCodings433_19[]; - asmError Opcode433(x64Operand& operand); - static Coding OpcodeCodings434_23[]; - static Coding OpcodeCodings434_19[]; - asmError Opcode434(x64Operand& operand); - static Coding OpcodeCodings435_23[]; - static Coding OpcodeCodings435_19[]; - asmError Opcode435(x64Operand& operand); - static Coding OpcodeCodings436_23[]; - static Coding OpcodeCodings436_19[]; - asmError Opcode436(x64Operand& operand); - static Coding OpcodeCodings437_23[]; - static Coding OpcodeCodings437_19[]; - asmError Opcode437(x64Operand& operand); - static Coding OpcodeCodings438_23[]; - static Coding OpcodeCodings438_19[]; - asmError Opcode438(x64Operand& operand); - static Coding OpcodeCodings439_23[]; - static Coding OpcodeCodings439_19[]; - asmError Opcode439(x64Operand& operand); - static Coding OpcodeCodings440_23[]; - static Coding OpcodeCodings440_19[]; - asmError Opcode440(x64Operand& operand); - static Coding OpcodeCodings441_23[]; - static Coding OpcodeCodings441_19[]; - asmError Opcode441(x64Operand& operand); - static Coding OpcodeCodings442_23[]; - static Coding OpcodeCodings442_19[]; - asmError Opcode442(x64Operand& operand); - static Coding OpcodeCodings443_23[]; - static Coding OpcodeCodings443_19[]; - asmError Opcode443(x64Operand& operand); - static Coding OpcodeCodings444_23[]; - static Coding OpcodeCodings444_19[]; - asmError Opcode444(x64Operand& operand); - static Coding OpcodeCodings445_23[]; - static Coding OpcodeCodings445_19[]; - asmError Opcode445(x64Operand& operand); - static Coding OpcodeCodings446_23[]; - static Coding OpcodeCodings446_19[]; - asmError Opcode446(x64Operand& operand); - static Coding OpcodeCodings447_23[]; - static Coding OpcodeCodings447_19[]; - asmError Opcode447(x64Operand& operand); - static Coding OpcodeCodings448_23[]; - static Coding OpcodeCodings448_19[]; - asmError Opcode448(x64Operand& operand); - static Coding OpcodeCodings449_23[]; - static Coding OpcodeCodings449_19[]; - asmError Opcode449(x64Operand& operand); - static Coding OpcodeCodings450_23[]; - static Coding OpcodeCodings450_19[]; - asmError Opcode450(x64Operand& operand); - static Coding OpcodeCodings451_23[]; - static Coding OpcodeCodings451_19[]; - asmError Opcode451(x64Operand& operand); - static Coding OpcodeCodings452_23[]; - static Coding OpcodeCodings452_19[]; - asmError Opcode452(x64Operand& operand); - static Coding OpcodeCodings453_23[]; - static Coding OpcodeCodings453_19[]; - asmError Opcode453(x64Operand& operand); - static Coding OpcodeCodings454_23[]; - static Coding OpcodeCodings454_19[]; - asmError Opcode454(x64Operand& operand); - static Coding OpcodeCodings455_23[]; - static Coding OpcodeCodings455_19[]; - asmError Opcode455(x64Operand& operand); - static Coding OpcodeCodings456_23[]; - static Coding OpcodeCodings456_19[]; - asmError Opcode456(x64Operand& operand); - static Coding OpcodeCodings457_23[]; - static Coding OpcodeCodings457_19[]; - asmError Opcode457(x64Operand& operand); - static Coding OpcodeCodings458_23[]; - static Coding OpcodeCodings458_19[]; - asmError Opcode458(x64Operand& operand); - static Coding OpcodeCodings459_23[]; - static Coding OpcodeCodings459_19[]; - asmError Opcode459(x64Operand& operand); - static Coding OpcodeCodings460_23[]; - static Coding OpcodeCodings460_19[]; - asmError Opcode460(x64Operand& operand); - static Coding OpcodeCodings461_23[]; - static Coding OpcodeCodings461_19[]; - asmError Opcode461(x64Operand& operand); - static Coding OpcodeCodings462_23[]; - static Coding OpcodeCodings462_19[]; - asmError Opcode462(x64Operand& operand); - asmError Opcode463(x64Operand& operand); - asmError Opcode464(x64Operand& operand); - static Coding OpcodeCodings465_23[]; - static Coding OpcodeCodings465_19[]; - asmError Opcode465(x64Operand& operand); - static Coding OpcodeCodings466_23[]; - static Coding OpcodeCodings466_19[]; - asmError Opcode466(x64Operand& operand); - static Coding OpcodeCodings467_23[]; - static Coding OpcodeCodings467_19[]; - asmError Opcode467(x64Operand& operand); - static Coding OpcodeCodings468_23[]; - static Coding OpcodeCodings468_19[]; - asmError Opcode468(x64Operand& operand); - static Coding OpcodeCodings469_19[]; - asmError Opcode469(x64Operand& operand); - static Coding OpcodeCodings470_23[]; - static Coding OpcodeCodings470_19[]; - asmError Opcode470(x64Operand& operand); - static Coding OpcodeCodings471_23[]; - static Coding OpcodeCodings471_19[]; - asmError Opcode471(x64Operand& operand); - static Coding OpcodeCodings472_23[]; - static Coding OpcodeCodings472_19[]; - asmError Opcode472(x64Operand& operand); - static Coding OpcodeCodings473_23[]; - static Coding OpcodeCodings473_19[]; - asmError Opcode473(x64Operand& operand); - static Coding OpcodeCodings474_23[]; - static Coding OpcodeCodings474_19[]; - asmError Opcode474(x64Operand& operand); - static Coding OpcodeCodings475_19[]; - asmError Opcode475(x64Operand& operand); - static Coding OpcodeCodings476_23[]; - static Coding OpcodeCodings476_36[]; - asmError Opcode476(x64Operand& operand); - static Coding OpcodeCodings477_23[]; - static Coding OpcodeCodings477_36[]; - asmError Opcode477(x64Operand& operand); - asmError Opcode478(x64Operand& operand); - asmError Opcode479(x64Operand& operand); - static Coding OpcodeCodings480_23[]; - static Coding OpcodeCodings480_19[]; - asmError Opcode480(x64Operand& operand); - static Coding OpcodeCodings481_23[]; - static Coding OpcodeCodings481_19[]; - asmError Opcode481(x64Operand& operand); - static Coding OpcodeCodings482_23[]; - static Coding OpcodeCodings482_36[]; - asmError Opcode482(x64Operand& operand); - static Coding OpcodeCodings483_23[]; - static Coding OpcodeCodings483_36[]; - asmError Opcode483(x64Operand& operand); - asmError Opcode484(x64Operand& operand); - static Coding OpcodeCodings485_23[]; - static Coding OpcodeCodings485_36[]; - asmError Opcode485(x64Operand& operand); - static Coding OpcodeCodings486_23[]; - static Coding OpcodeCodings486_36[]; - asmError Opcode486(x64Operand& operand); - asmError Opcode487(x64Operand& operand); - static Coding OpcodeCodings488_23[]; - static Coding OpcodeCodings488_36[]; - asmError Opcode488(x64Operand& operand); - static Coding OpcodeCodings489_23[]; - static Coding OpcodeCodings489_36[]; - asmError Opcode489(x64Operand& operand); - static Coding OpcodeCodings490_23[]; - static Coding OpcodeCodings490_19[]; - asmError Opcode490(x64Operand& operand); - static Coding OpcodeCodings491_23[]; - static Coding OpcodeCodings491_19[]; - asmError Opcode491(x64Operand& operand); - asmError Opcode492(x64Operand& operand); - static Coding OpcodeCodings493_19[]; - asmError Opcode493(x64Operand& operand); - asmError Opcode494(x64Operand& operand); - asmError Opcode495(x64Operand& operand); - asmError Opcode496(x64Operand& operand); - asmError Opcode497(x64Operand& operand); - static Coding OpcodeCodings498_23[]; - static Coding OpcodeCodings498_19[]; - asmError Opcode498(x64Operand& operand); - static Coding OpcodeCodings499_23[]; - static Coding OpcodeCodings499_19[]; - asmError Opcode499(x64Operand& operand); - static Coding OpcodeCodings500_23[]; - static Coding OpcodeCodings500_36[]; - asmError Opcode500(x64Operand& operand); - static Coding OpcodeCodings501_23[]; - static Coding OpcodeCodings501_36[]; - asmError Opcode501(x64Operand& operand); - static Coding OpcodeCodings502_23[]; - static Coding OpcodeCodings502_36[]; - asmError Opcode502(x64Operand& operand); - static Coding OpcodeCodings503_23[]; - static Coding OpcodeCodings503_19[]; - asmError Opcode503(x64Operand& operand); - static Coding OpcodeCodings504_23[]; - static Coding OpcodeCodings504_19[]; - asmError Opcode504(x64Operand& operand); - static Coding OpcodeCodings505_23[]; - static Coding OpcodeCodings505_19[]; - asmError Opcode505(x64Operand& operand); - static Coding OpcodeCodings506_23[]; - static Coding OpcodeCodings506_19[]; - asmError Opcode506(x64Operand& operand); - static Coding OpcodeCodings507_23[]; - static Coding OpcodeCodings507_19[]; - asmError Opcode507(x64Operand& operand); - static Coding OpcodeCodings508_23[]; - static Coding OpcodeCodings508_19[]; - asmError Opcode508(x64Operand& operand); - static Coding OpcodeCodings509_23[]; - static Coding OpcodeCodings509_19[]; - asmError Opcode509(x64Operand& operand); - static Coding OpcodeCodings510_19[]; - asmError Opcode510(x64Operand& operand); - static Coding OpcodeCodings511_19[]; - asmError Opcode511(x64Operand& operand); - static Coding OpcodeCodings512_23[]; - static Coding OpcodeCodings512_19[]; - asmError Opcode512(x64Operand& operand); - static Coding OpcodeCodings513_19[]; - asmError Opcode513(x64Operand& operand); - static Coding OpcodeCodings514_19[]; - asmError Opcode514(x64Operand& operand); - static Coding OpcodeCodings515_19[]; - asmError Opcode515(x64Operand& operand); - static Coding OpcodeCodings516_19[]; - asmError Opcode516(x64Operand& operand); - static Coding OpcodeCodings517_19[]; - asmError Opcode517(x64Operand& operand); - static Coding OpcodeCodings518_19[]; - asmError Opcode518(x64Operand& operand); - static Coding OpcodeCodings519_19[]; - asmError Opcode519(x64Operand& operand); - static Coding OpcodeCodings520_19[]; - asmError Opcode520(x64Operand& operand); - static Coding OpcodeCodings521_19[]; - asmError Opcode521(x64Operand& operand); - static Coding OpcodeCodings522_19[]; - asmError Opcode522(x64Operand& operand); - static Coding OpcodeCodings523_19[]; - asmError Opcode523(x64Operand& operand); - static Coding OpcodeCodings524_19[]; - asmError Opcode524(x64Operand& operand); - static Coding OpcodeCodings525_23[]; - static Coding OpcodeCodings525_19[]; - asmError Opcode525(x64Operand& operand); - static Coding OpcodeCodings526_19[]; - asmError Opcode526(x64Operand& operand); - static Coding OpcodeCodings527_19[]; - asmError Opcode527(x64Operand& operand); - static Coding OpcodeCodings528_19[]; - asmError Opcode528(x64Operand& operand); - static Coding OpcodeCodings529_23[]; - static Coding OpcodeCodings529_19[]; - asmError Opcode529(x64Operand& operand); - static Coding OpcodeCodings530_23[]; - static Coding OpcodeCodings530_19[]; - asmError Opcode530(x64Operand& operand); - static Coding OpcodeCodings531_19[]; - asmError Opcode531(x64Operand& operand); - static Coding OpcodeCodings532_19[]; - asmError Opcode532(x64Operand& operand); - static Coding OpcodeCodings533_19[]; - asmError Opcode533(x64Operand& operand); - static Coding OpcodeCodings534_19[]; - asmError Opcode534(x64Operand& operand); - static Coding OpcodeCodings535_19[]; - asmError Opcode535(x64Operand& operand); - static Coding OpcodeCodings536_19[]; - asmError Opcode536(x64Operand& operand); - asmError Opcode537(x64Operand& operand); - static Coding OpcodeCodings538_19[]; - asmError Opcode538(x64Operand& operand); - static Coding OpcodeCodings539_19[]; - asmError Opcode539(x64Operand& operand); - static Coding OpcodeCodings540_19[]; - asmError Opcode540(x64Operand& operand); - asmError Opcode541(x64Operand& operand); - static Coding OpcodeCodings542_19[]; - asmError Opcode542(x64Operand& operand); - static Coding OpcodeCodings543_19[]; - asmError Opcode543(x64Operand& operand); - static Coding OpcodeCodings544_19[]; - asmError Opcode544(x64Operand& operand); - static Coding OpcodeCodings545_19[]; - asmError Opcode545(x64Operand& operand); - static Coding OpcodeCodings546_19[]; - asmError Opcode546(x64Operand& operand); - static Coding OpcodeCodings547_19[]; - asmError Opcode547(x64Operand& operand); - static Coding OpcodeCodings548_19[]; - asmError Opcode548(x64Operand& operand); - static Coding OpcodeCodings549_19[]; - asmError Opcode549(x64Operand& operand); - static Coding OpcodeCodings550_19[]; - asmError Opcode550(x64Operand& operand); - static Coding OpcodeCodings551_19[]; - asmError Opcode551(x64Operand& operand); - static Coding OpcodeCodings552_19[]; - asmError Opcode552(x64Operand& operand); - static Coding OpcodeCodings553_23[]; - static Coding OpcodeCodings553_19[]; - asmError Opcode553(x64Operand& operand); - static Coding OpcodeCodings554_23[]; - static Coding OpcodeCodings554_19[]; - asmError Opcode554(x64Operand& operand); - static Coding OpcodeCodings555_23[]; - static Coding OpcodeCodings555_19[]; - asmError Opcode555(x64Operand& operand); - static Coding OpcodeCodings556_23[]; - static Coding OpcodeCodings556_19[]; - asmError Opcode556(x64Operand& operand); - static Coding OpcodeCodings557_39[]; - static Coding OpcodeCodings557_36[]; - static Coding OpcodeCodings557_37[]; - asmError Opcode557(x64Operand& operand); - static Coding OpcodeCodings558_23[]; - static Coding OpcodeCodings558_19[]; - asmError Opcode558(x64Operand& operand); - static Coding OpcodeCodings559_39[]; - static Coding OpcodeCodings559_36[]; - static Coding OpcodeCodings559_37[]; - asmError Opcode559(x64Operand& operand); - static Coding OpcodeCodings560_39[]; - static Coding OpcodeCodings560_36[]; - static Coding OpcodeCodings560_37[]; - asmError Opcode560(x64Operand& operand); - static Coding OpcodeCodings561_39[]; - static Coding OpcodeCodings561_36[]; - static Coding OpcodeCodings561_37[]; - asmError Opcode561(x64Operand& operand); - static Coding OpcodeCodings562_39[]; - static Coding OpcodeCodings562_36[]; - static Coding OpcodeCodings562_37[]; - asmError Opcode562(x64Operand& operand); - static Coding OpcodeCodings563_39[]; - static Coding OpcodeCodings563_36[]; - static Coding OpcodeCodings563_37[]; - asmError Opcode563(x64Operand& operand); - static Coding OpcodeCodings564_23[]; - static Coding OpcodeCodings564_19[]; - asmError Opcode564(x64Operand& operand); - static Coding OpcodeCodings565_39[]; - static Coding OpcodeCodings565_36[]; - static Coding OpcodeCodings565_37[]; - asmError Opcode565(x64Operand& operand); - static Coding OpcodeCodings566_39[]; - static Coding OpcodeCodings566_36[]; - static Coding OpcodeCodings566_37[]; - asmError Opcode566(x64Operand& operand); - static Coding OpcodeCodings567_19[]; - asmError Opcode567(x64Operand& operand); - static Coding OpcodeCodings568_19[]; - asmError Opcode568(x64Operand& operand); - static Coding OpcodeCodings569_19[]; - asmError Opcode569(x64Operand& operand); - static Coding OpcodeCodings570_19[]; - asmError Opcode570(x64Operand& operand); - static Coding OpcodeCodings571_19[]; - asmError Opcode571(x64Operand& operand); - static Coding OpcodeCodings572_19[]; - asmError Opcode572(x64Operand& operand); - static Coding OpcodeCodings573_19[]; - asmError Opcode573(x64Operand& operand); - static Coding OpcodeCodings574_19[]; - asmError Opcode574(x64Operand& operand); - static Coding OpcodeCodings575_19[]; - asmError Opcode575(x64Operand& operand); - static Coding OpcodeCodings576_23[]; - static Coding OpcodeCodings576_19[]; - asmError Opcode576(x64Operand& operand); - static Coding OpcodeCodings577_19[]; - asmError Opcode577(x64Operand& operand); - static Coding OpcodeCodings578_19[]; - asmError Opcode578(x64Operand& operand); - static Coding OpcodeCodings579_19[]; - asmError Opcode579(x64Operand& operand); - static Coding OpcodeCodings580_23[]; - static Coding OpcodeCodings580_19[]; - asmError Opcode580(x64Operand& operand); - static Coding OpcodeCodings581_19[]; - asmError Opcode581(x64Operand& operand); - static Coding OpcodeCodings582_19[]; - asmError Opcode582(x64Operand& operand); - static Coding OpcodeCodings583_23[]; - static Coding OpcodeCodings583_19[]; - asmError Opcode583(x64Operand& operand); - static Coding OpcodeCodings584_23[]; - static Coding OpcodeCodings584_19[]; - asmError Opcode584(x64Operand& operand); - static Coding OpcodeCodings585_23[]; - static Coding OpcodeCodings585_19[]; - asmError Opcode585(x64Operand& operand); - static Coding OpcodeCodings586_23[]; - static Coding OpcodeCodings586_19[]; - asmError Opcode586(x64Operand& operand); - static Coding OpcodeCodings587_23[]; - static Coding OpcodeCodings587_19[]; - asmError Opcode587(x64Operand& operand); - static Coding OpcodeCodings588_23[]; - static Coding OpcodeCodings588_19[]; - asmError Opcode588(x64Operand& operand); - static Coding OpcodeCodings589_23[]; - static Coding OpcodeCodings589_19[]; - asmError Opcode589(x64Operand& operand); - static Coding OpcodeCodings590_23[]; - static Coding OpcodeCodings590_19[]; - asmError Opcode590(x64Operand& operand); - static Coding OpcodeCodings591_23[]; - static Coding OpcodeCodings591_19[]; - asmError Opcode591(x64Operand& operand); - static Coding OpcodeCodings592_23[]; - static Coding OpcodeCodings592_19[]; - asmError Opcode592(x64Operand& operand); - static Coding OpcodeCodings593_23[]; - static Coding OpcodeCodings593_19[]; - asmError Opcode593(x64Operand& operand); - static Coding OpcodeCodings594_23[]; - static Coding OpcodeCodings594_19[]; - asmError Opcode594(x64Operand& operand); - static Coding OpcodeCodings595_23[]; - static Coding OpcodeCodings595_19[]; - asmError Opcode595(x64Operand& operand); - static Coding OpcodeCodings596_23[]; - static Coding OpcodeCodings596_19[]; - asmError Opcode596(x64Operand& operand); - static Coding OpcodeCodings597_23[]; - static Coding OpcodeCodings597_19[]; - asmError Opcode597(x64Operand& operand); - static Coding OpcodeCodings598_23[]; - static Coding OpcodeCodings598_19[]; - asmError Opcode598(x64Operand& operand); - static Coding OpcodeCodings599_23[]; - static Coding OpcodeCodings599_19[]; - asmError Opcode599(x64Operand& operand); - static Coding OpcodeCodings600_23[]; - static Coding OpcodeCodings600_19[]; - asmError Opcode600(x64Operand& operand); - static Coding OpcodeCodings601_23[]; - static Coding OpcodeCodings601_19[]; - asmError Opcode601(x64Operand& operand); - static Coding OpcodeCodings602_23[]; - static Coding OpcodeCodings602_19[]; - asmError Opcode602(x64Operand& operand); - static Coding OpcodeCodings603_23[]; - static Coding OpcodeCodings603_19[]; - asmError Opcode603(x64Operand& operand); - static Coding OpcodeCodings604_23[]; - static Coding OpcodeCodings604_19[]; - asmError Opcode604(x64Operand& operand); - static Coding OpcodeCodings605_23[]; - static Coding OpcodeCodings605_19[]; - asmError Opcode605(x64Operand& operand); - static Coding OpcodeCodings606_23[]; - static Coding OpcodeCodings606_19[]; - asmError Opcode606(x64Operand& operand); - static Coding OpcodeCodings607_23[]; - static Coding OpcodeCodings607_19[]; - asmError Opcode607(x64Operand& operand); - static Coding OpcodeCodings608_23[]; - static Coding OpcodeCodings608_19[]; - asmError Opcode608(x64Operand& operand); - asmError Opcode609(x64Operand& operand); - asmError Opcode610(x64Operand& operand); - asmError Opcode611(x64Operand& operand); - asmError Opcode612(x64Operand& operand); - asmError Opcode613(x64Operand& operand); - asmError Opcode614(x64Operand& operand); - asmError Opcode615(x64Operand& operand); - asmError Opcode616(x64Operand& operand); - asmError Opcode617(x64Operand& operand); - asmError Opcode618(x64Operand& operand); - asmError Opcode619(x64Operand& operand); - asmError Opcode620(x64Operand& operand); + asmError Opcode0(x64Operand &operand); + asmError Opcode1(x64Operand &operand); + asmError Opcode2(x64Operand &operand); + asmError Opcode3(x64Operand &operand); + asmError Opcode4(x64Operand &operand); + asmError Opcode5(x64Operand &operand); + asmError Opcode6(x64Operand &operand); + asmError Opcode7(x64Operand &operand); + asmError Opcode8(x64Operand &operand); + asmError Opcode9(x64Operand &operand); + asmError Opcode10(x64Operand &operand); + asmError Opcode11(x64Operand &operand); + asmError Opcode12(x64Operand &operand); + asmError Opcode13(x64Operand &operand); + asmError Opcode14(x64Operand &operand); + asmError Opcode15(x64Operand &operand); + asmError Opcode16(x64Operand &operand); + asmError Opcode17(x64Operand &operand); + asmError Opcode18(x64Operand &operand); + asmError Opcode19(x64Operand &operand); + asmError Opcode20(x64Operand &operand); + asmError Opcode21(x64Operand &operand); + asmError Opcode22(x64Operand &operand); + asmError Opcode23(x64Operand &operand); + asmError Opcode24(x64Operand &operand); + asmError Opcode25(x64Operand &operand); + asmError Opcode26(x64Operand &operand); + asmError Opcode27(x64Operand &operand); + asmError Opcode28(x64Operand &operand); + asmError Opcode29(x64Operand &operand); + asmError Opcode30(x64Operand &operand); + asmError Opcode31(x64Operand &operand); + static Coding OpcodeCodings32_19[]; + asmError Opcode32(x64Operand &operand); + static Coding OpcodeCodings33_19[]; + asmError Opcode33(x64Operand &operand); + static Coding OpcodeCodings34_19[]; + asmError Opcode34(x64Operand &operand); + static Coding OpcodeCodings35_19[]; + asmError Opcode35(x64Operand &operand); + static Coding OpcodeCodings36_18[]; + static Coding OpcodeCodings36_36[]; + static Coding OpcodeCodings36_37[]; + asmError Opcode36(x64Operand &operand); + static Coding OpcodeCodings37_18[]; + static Coding OpcodeCodings37_36[]; + static Coding OpcodeCodings37_37[]; + asmError Opcode37(x64Operand &operand); + static Coding OpcodeCodings38_18[]; + static Coding OpcodeCodings38_36[]; + static Coding OpcodeCodings38_37[]; + asmError Opcode38(x64Operand &operand); + asmError Opcode39(x64Operand &operand); + static Coding OpcodeCodings40_36[]; + asmError Opcode40(x64Operand &operand); + static Coding OpcodeCodings41_36[]; + asmError Opcode41(x64Operand &operand); + static Coding OpcodeCodings42_36[]; + asmError Opcode42(x64Operand &operand); + asmError Opcode43(x64Operand &operand); + static Coding OpcodeCodings44_18[]; + static Coding OpcodeCodings44_36[]; + static Coding OpcodeCodings44_37[]; + asmError Opcode44(x64Operand &operand); + static Coding OpcodeCodings45_18[]; + static Coding OpcodeCodings45_36[]; + static Coding OpcodeCodings45_37[]; + asmError Opcode45(x64Operand &operand); + static Coding OpcodeCodings46_18[]; + static Coding OpcodeCodings46_36[]; + static Coding OpcodeCodings46_37[]; + asmError Opcode46(x64Operand &operand); + static Coding OpcodeCodings47_18[]; + static Coding OpcodeCodings47_36[]; + static Coding OpcodeCodings47_37[]; + asmError Opcode47(x64Operand &operand); + asmError Opcode48(x64Operand &operand); + static Coding OpcodeCodings49_19[]; + asmError Opcode49(x64Operand &operand); + static Coding OpcodeCodings50_19[]; + asmError Opcode50(x64Operand &operand); + asmError Opcode51(x64Operand &operand); + static Coding OpcodeCodings52_19[]; + asmError Opcode52(x64Operand &operand); + static Coding OpcodeCodings53_19[]; + asmError Opcode53(x64Operand &operand); + static Coding OpcodeCodings54_19[]; + asmError Opcode54(x64Operand &operand); + static Coding OpcodeCodings55_19[]; + asmError Opcode55(x64Operand &operand); + static Coding OpcodeCodings56_19[]; + asmError Opcode56(x64Operand &operand); + static Coding OpcodeCodings57_38[]; + asmError Opcode57(x64Operand &operand); + static Coding OpcodeCodings58_38[]; + asmError Opcode58(x64Operand &operand); + static Coding OpcodeCodings59_38[]; + asmError Opcode59(x64Operand &operand); + static Coding OpcodeCodings60_38[]; + asmError Opcode60(x64Operand &operand); + static Coding OpcodeCodings61_38[]; + asmError Opcode61(x64Operand &operand); + static Coding OpcodeCodings62_38[]; + asmError Opcode62(x64Operand &operand); + static Coding OpcodeCodings63_38[]; + asmError Opcode63(x64Operand &operand); + static Coding OpcodeCodings64_38[]; + asmError Opcode64(x64Operand &operand); + static Coding OpcodeCodings65_38[]; + asmError Opcode65(x64Operand &operand); + static Coding OpcodeCodings66_38[]; + asmError Opcode66(x64Operand &operand); + static Coding OpcodeCodings67_38[]; + asmError Opcode67(x64Operand &operand); + static Coding OpcodeCodings68_38[]; + asmError Opcode68(x64Operand &operand); + static Coding OpcodeCodings69_38[]; + asmError Opcode69(x64Operand &operand); + static Coding OpcodeCodings70_38[]; + asmError Opcode70(x64Operand &operand); + static Coding OpcodeCodings71_38[]; + asmError Opcode71(x64Operand &operand); + static Coding OpcodeCodings72_38[]; + asmError Opcode72(x64Operand &operand); + static Coding OpcodeCodings73_38[]; + asmError Opcode73(x64Operand &operand); + static Coding OpcodeCodings74_38[]; + asmError Opcode74(x64Operand &operand); + static Coding OpcodeCodings75_38[]; + asmError Opcode75(x64Operand &operand); + static Coding OpcodeCodings76_38[]; + asmError Opcode76(x64Operand &operand); + static Coding OpcodeCodings77_38[]; + asmError Opcode77(x64Operand &operand); + static Coding OpcodeCodings78_38[]; + asmError Opcode78(x64Operand &operand); + static Coding OpcodeCodings79_38[]; + asmError Opcode79(x64Operand &operand); + static Coding OpcodeCodings80_38[]; + asmError Opcode80(x64Operand &operand); + static Coding OpcodeCodings81_38[]; + asmError Opcode81(x64Operand &operand); + static Coding OpcodeCodings82_38[]; + asmError Opcode82(x64Operand &operand); + static Coding OpcodeCodings83_38[]; + asmError Opcode83(x64Operand &operand); + static Coding OpcodeCodings84_38[]; + asmError Opcode84(x64Operand &operand); + static Coding OpcodeCodings85_38[]; + asmError Opcode85(x64Operand &operand); + static Coding OpcodeCodings86_38[]; + asmError Opcode86(x64Operand &operand); + static Coding OpcodeCodings87_18[]; + static Coding OpcodeCodings87_36[]; + static Coding OpcodeCodings87_37[]; + asmError Opcode87(x64Operand &operand); + asmError Opcode88(x64Operand &operand); + static Coding OpcodeCodings89_19[]; + asmError Opcode89(x64Operand &operand); + static Coding OpcodeCodings90_19[]; + asmError Opcode90(x64Operand &operand); + static Coding OpcodeCodings91_19[]; + asmError Opcode91(x64Operand &operand); + asmError Opcode92(x64Operand &operand); + static Coding OpcodeCodings93_36[]; + asmError Opcode93(x64Operand &operand); + asmError Opcode94(x64Operand &operand); + asmError Opcode95(x64Operand &operand); + static Coding OpcodeCodings96_19[]; + asmError Opcode96(x64Operand &operand); + asmError Opcode97(x64Operand &operand); + static Coding OpcodeCodings98_19[]; + asmError Opcode98(x64Operand &operand); + static Coding OpcodeCodings99_19[]; + asmError Opcode99(x64Operand &operand); + static Coding OpcodeCodings100_19[]; + asmError Opcode100(x64Operand &operand); + static Coding OpcodeCodings101_19[]; + asmError Opcode101(x64Operand &operand); + static Coding OpcodeCodings102_18[]; + static Coding OpcodeCodings102_19[]; + asmError Opcode102(x64Operand &operand); + static Coding OpcodeCodings103_18[]; + asmError Opcode103(x64Operand &operand); + asmError Opcode104(x64Operand &operand); + asmError Opcode105(x64Operand &operand); + static Coding OpcodeCodings106_19[]; + asmError Opcode106(x64Operand &operand); + static Coding OpcodeCodings107_19[]; + asmError Opcode107(x64Operand &operand); + static Coding OpcodeCodings108_18[]; + static Coding OpcodeCodings108_39[]; + static Coding OpcodeCodings108_36[]; + asmError Opcode108(x64Operand &operand); + static Coding OpcodeCodings109_18[]; + static Coding OpcodeCodings109_19[]; + asmError Opcode109(x64Operand &operand); + static Coding OpcodeCodings110_18[]; + static Coding OpcodeCodings110_19[]; + asmError Opcode110(x64Operand &operand); + static Coding OpcodeCodings111_18[]; + static Coding OpcodeCodings111_19[]; + asmError Opcode111(x64Operand &operand); + static Coding OpcodeCodings112_19[]; + asmError Opcode112(x64Operand &operand); + static Coding OpcodeCodings113_19[]; + asmError Opcode113(x64Operand &operand); + static Coding OpcodeCodings114_19[]; + asmError Opcode114(x64Operand &operand); + static Coding OpcodeCodings115_18[]; + static Coding OpcodeCodings115_36[]; + asmError Opcode115(x64Operand &operand); + static Coding OpcodeCodings116_18[]; + static Coding OpcodeCodings116_36[]; + asmError Opcode116(x64Operand &operand); + static Coding OpcodeCodings117_18[]; + static Coding OpcodeCodings117_36[]; + asmError Opcode117(x64Operand &operand); + static Coding OpcodeCodings118_18[]; + static Coding OpcodeCodings118_36[]; + asmError Opcode118(x64Operand &operand); + static Coding OpcodeCodings119_18[]; + static Coding OpcodeCodings119_36[]; + asmError Opcode119(x64Operand &operand); + static Coding OpcodeCodings120_18[]; + static Coding OpcodeCodings120_36[]; + asmError Opcode120(x64Operand &operand); + static Coding OpcodeCodings121_18[]; + static Coding OpcodeCodings121_36[]; + asmError Opcode121(x64Operand &operand); + static Coding OpcodeCodings122_18[]; + static Coding OpcodeCodings122_36[]; + asmError Opcode122(x64Operand &operand); + static Coding OpcodeCodings123_18[]; + static Coding OpcodeCodings123_36[]; + asmError Opcode123(x64Operand &operand); + static Coding OpcodeCodings124_18[]; + static Coding OpcodeCodings124_36[]; + asmError Opcode124(x64Operand &operand); + static Coding OpcodeCodings125_18[]; + static Coding OpcodeCodings125_36[]; + asmError Opcode125(x64Operand &operand); + static Coding OpcodeCodings126_18[]; + static Coding OpcodeCodings126_36[]; + asmError Opcode126(x64Operand &operand); + static Coding OpcodeCodings127_19[]; + asmError Opcode127(x64Operand &operand); + static Coding OpcodeCodings128_19[]; + asmError Opcode128(x64Operand &operand); + static Coding OpcodeCodings129_19[]; + asmError Opcode129(x64Operand &operand); + static Coding OpcodeCodings130_19[]; + asmError Opcode130(x64Operand &operand); + static Coding OpcodeCodings131_18[]; + static Coding OpcodeCodings131_39[]; + static Coding OpcodeCodings131_36[]; + asmError Opcode131(x64Operand &operand); + static Coding OpcodeCodings132_18[]; + static Coding OpcodeCodings132_19[]; + asmError Opcode132(x64Operand &operand); + static Coding OpcodeCodings133_18[]; + static Coding OpcodeCodings133_39[]; + static Coding OpcodeCodings133_36[]; + asmError Opcode133(x64Operand &operand); + static Coding OpcodeCodings134_18[]; + static Coding OpcodeCodings134_19[]; + asmError Opcode134(x64Operand &operand); + static Coding OpcodeCodings135_19[]; + asmError Opcode135(x64Operand &operand); + asmError Opcode136(x64Operand &operand); + asmError Opcode137(x64Operand &operand); + static Coding OpcodeCodings138_18[]; + static Coding OpcodeCodings138_36[]; + asmError Opcode138(x64Operand &operand); + static Coding OpcodeCodings139_18[]; + static Coding OpcodeCodings139_36[]; + asmError Opcode139(x64Operand &operand); + static Coding OpcodeCodings140_18[]; + static Coding OpcodeCodings140_36[]; + asmError Opcode140(x64Operand &operand); + static Coding OpcodeCodings141_18[]; + static Coding OpcodeCodings141_36[]; + asmError Opcode141(x64Operand &operand); + static Coding OpcodeCodings142_18[]; + static Coding OpcodeCodings142_36[]; + asmError Opcode142(x64Operand &operand); + static Coding OpcodeCodings143_18[]; + static Coding OpcodeCodings143_36[]; + asmError Opcode143(x64Operand &operand); + static Coding OpcodeCodings144_18[]; + static Coding OpcodeCodings144_36[]; + asmError Opcode144(x64Operand &operand); + static Coding OpcodeCodings145_19[]; + asmError Opcode145(x64Operand &operand); + static Coding OpcodeCodings146_19[]; + asmError Opcode146(x64Operand &operand); + static Coding OpcodeCodings147_19[]; + asmError Opcode147(x64Operand &operand); + static Coding OpcodeCodings148_18[]; + static Coding OpcodeCodings148_36[]; + asmError Opcode148(x64Operand &operand); + static Coding OpcodeCodings149_18[]; + static Coding OpcodeCodings149_36[]; + asmError Opcode149(x64Operand &operand); + static Coding OpcodeCodings150_18[]; + static Coding OpcodeCodings150_36[]; + asmError Opcode150(x64Operand &operand); + static Coding OpcodeCodings151_18[]; + static Coding OpcodeCodings151_36[]; + asmError Opcode151(x64Operand &operand); + asmError Opcode152(x64Operand &operand); + static Coding OpcodeCodings153_19[]; + asmError Opcode153(x64Operand &operand); + asmError Opcode154(x64Operand &operand); + asmError Opcode155(x64Operand &operand); + static Coding OpcodeCodings156_19[]; + asmError Opcode156(x64Operand &operand); + static Coding OpcodeCodings157_19[]; + asmError Opcode157(x64Operand &operand); + static Coding OpcodeCodings158_19[]; + asmError Opcode158(x64Operand &operand); + static Coding OpcodeCodings159_19[]; + asmError Opcode159(x64Operand &operand); + static Coding OpcodeCodings160_19[]; + asmError Opcode160(x64Operand &operand); + static Coding OpcodeCodings161_19[]; + asmError Opcode161(x64Operand &operand); + static Coding OpcodeCodings162_18[]; + static Coding OpcodeCodings162_39[]; + static Coding OpcodeCodings162_36[]; + asmError Opcode162(x64Operand &operand); + static Coding OpcodeCodings163_18[]; + static Coding OpcodeCodings163_19[]; + asmError Opcode163(x64Operand &operand); + static Coding OpcodeCodings164_19[]; + asmError Opcode164(x64Operand &operand); + asmError Opcode165(x64Operand &operand); + static Coding OpcodeCodings166_19[]; + asmError Opcode166(x64Operand &operand); + static Coding OpcodeCodings167_19[]; + asmError Opcode167(x64Operand &operand); + static Coding OpcodeCodings168_19[]; + asmError Opcode168(x64Operand &operand); + static Coding OpcodeCodings169_19[]; + asmError Opcode169(x64Operand &operand); + static Coding OpcodeCodings170_19[]; + asmError Opcode170(x64Operand &operand); + asmError Opcode171(x64Operand &operand); + asmError Opcode172(x64Operand &operand); + static Coding OpcodeCodings173_19[]; + asmError Opcode173(x64Operand &operand); + static Coding OpcodeCodings174_19[]; + asmError Opcode174(x64Operand &operand); + static Coding OpcodeCodings175_19[]; + asmError Opcode175(x64Operand &operand); + static Coding OpcodeCodings176_19[]; + asmError Opcode176(x64Operand &operand); + static Coding OpcodeCodings177_19[]; + asmError Opcode177(x64Operand &operand); + asmError Opcode178(x64Operand &operand); + asmError Opcode179(x64Operand &operand); + asmError Opcode180(x64Operand &operand); + asmError Opcode181(x64Operand &operand); + asmError Opcode182(x64Operand &operand); + asmError Opcode183(x64Operand &operand); + asmError Opcode184(x64Operand &operand); + asmError Opcode185(x64Operand &operand); + static Coding OpcodeCodings186_18[]; + static Coding OpcodeCodings186_39[]; + static Coding OpcodeCodings186_36[]; + asmError Opcode186(x64Operand &operand); + static Coding OpcodeCodings187_18[]; + static Coding OpcodeCodings187_19[]; + asmError Opcode187(x64Operand &operand); + static Coding OpcodeCodings188_18[]; + static Coding OpcodeCodings188_39[]; + static Coding OpcodeCodings188_36[]; + asmError Opcode188(x64Operand &operand); + static Coding OpcodeCodings189_18[]; + static Coding OpcodeCodings189_19[]; + asmError Opcode189(x64Operand &operand); + static Coding OpcodeCodings190_19[]; + asmError Opcode190(x64Operand &operand); + static Coding OpcodeCodings191_18[]; + static Coding OpcodeCodings191_19[]; + asmError Opcode191(x64Operand &operand); + static Coding OpcodeCodings192_18[]; + static Coding OpcodeCodings192_36[]; + asmError Opcode192(x64Operand &operand); + static Coding OpcodeCodings193_18[]; + static Coding OpcodeCodings193_36[]; + asmError Opcode193(x64Operand &operand); + static Coding OpcodeCodings194_18[]; + static Coding OpcodeCodings194_19[]; + asmError Opcode194(x64Operand &operand); + static Coding OpcodeCodings195_19[]; + asmError Opcode195(x64Operand &operand); + static Coding OpcodeCodings196_19[]; + asmError Opcode196(x64Operand &operand); + static Coding OpcodeCodings197_19[]; + asmError Opcode197(x64Operand &operand); + static Coding OpcodeCodings198_18[]; + static Coding OpcodeCodings198_19[]; + asmError Opcode198(x64Operand &operand); + static Coding OpcodeCodings199_18[]; + static Coding OpcodeCodings199_36[]; + asmError Opcode199(x64Operand &operand); + static Coding OpcodeCodings200_18[]; + static Coding OpcodeCodings200_36[]; + asmError Opcode200(x64Operand &operand); + asmError Opcode201(x64Operand &operand); + asmError Opcode202(x64Operand &operand); + static Coding OpcodeCodings203_19[]; + asmError Opcode203(x64Operand &operand); + static Coding OpcodeCodings204_19[]; + asmError Opcode204(x64Operand &operand); + static Coding OpcodeCodings205_19[]; + asmError Opcode205(x64Operand &operand); + static Coding OpcodeCodings206_19[]; + asmError Opcode206(x64Operand &operand); + static Coding OpcodeCodings207_19[]; + asmError Opcode207(x64Operand &operand); + static Coding OpcodeCodings208_18[]; + asmError Opcode208(x64Operand &operand); + asmError Opcode209(x64Operand &operand); + asmError Opcode210(x64Operand &operand); + asmError Opcode211(x64Operand &operand); + static Coding OpcodeCodings212_19[]; + asmError Opcode212(x64Operand &operand); + static Coding OpcodeCodings213_19[]; + asmError Opcode213(x64Operand &operand); + static Coding OpcodeCodings214_19[]; + asmError Opcode214(x64Operand &operand); + static Coding OpcodeCodings215_18[]; + static Coding OpcodeCodings215_19[]; + asmError Opcode215(x64Operand &operand); + asmError Opcode216(x64Operand &operand); + static Coding OpcodeCodings217_19[]; + asmError Opcode217(x64Operand &operand); + static Coding OpcodeCodings218_19[]; + asmError Opcode218(x64Operand &operand); + static Coding OpcodeCodings219_19[]; + asmError Opcode219(x64Operand &operand); + static Coding OpcodeCodings220_19[]; + asmError Opcode220(x64Operand &operand); + asmError Opcode221(x64Operand &operand); + static Coding OpcodeCodings222_19[]; + asmError Opcode222(x64Operand &operand); + static Coding OpcodeCodings223_19[]; + asmError Opcode223(x64Operand &operand); + asmError Opcode224(x64Operand &operand); + static Coding OpcodeCodings225_19[]; + asmError Opcode225(x64Operand &operand); + static Coding OpcodeCodings226_38[]; + asmError Opcode226(x64Operand &operand); + static Coding OpcodeCodings227_38[]; + asmError Opcode227(x64Operand &operand); + static Coding OpcodeCodings228_38[]; + asmError Opcode228(x64Operand &operand); + static Coding OpcodeCodings229_38[]; + asmError Opcode229(x64Operand &operand); + static Coding OpcodeCodings230_38[]; + asmError Opcode230(x64Operand &operand); + asmError Opcode231(x64Operand &operand); + asmError Opcode232(x64Operand &operand); + static Coding OpcodeCodings233_38[]; + asmError Opcode233(x64Operand &operand); + static Coding OpcodeCodings234_38[]; + asmError Opcode234(x64Operand &operand); + static Coding OpcodeCodings235_38[]; + asmError Opcode235(x64Operand &operand); + static Coding OpcodeCodings236_38[]; + asmError Opcode236(x64Operand &operand); + static Coding OpcodeCodings237_38[]; + asmError Opcode237(x64Operand &operand); + asmError Opcode238(x64Operand &operand); + static Coding OpcodeCodings239_38[]; + asmError Opcode239(x64Operand &operand); + static Coding OpcodeCodings240_38[]; + asmError Opcode240(x64Operand &operand); + static Coding OpcodeCodings241_38[]; + asmError Opcode241(x64Operand &operand); + static Coding OpcodeCodings242_38[]; + asmError Opcode242(x64Operand &operand); + static Coding OpcodeCodings243_38[]; + asmError Opcode243(x64Operand &operand); + static Coding OpcodeCodings244_38[]; + asmError Opcode244(x64Operand &operand); + static Coding OpcodeCodings245_38[]; + asmError Opcode245(x64Operand &operand); + static Coding OpcodeCodings246_38[]; + asmError Opcode246(x64Operand &operand); + static Coding OpcodeCodings247_38[]; + asmError Opcode247(x64Operand &operand); + static Coding OpcodeCodings248_38[]; + asmError Opcode248(x64Operand &operand); + static Coding OpcodeCodings249_38[]; + asmError Opcode249(x64Operand &operand); + static Coding OpcodeCodings250_38[]; + asmError Opcode250(x64Operand &operand); + static Coding OpcodeCodings251_38[]; + asmError Opcode251(x64Operand &operand); + static Coding OpcodeCodings252_38[]; + asmError Opcode252(x64Operand &operand); + static Coding OpcodeCodings253_38[]; + asmError Opcode253(x64Operand &operand); + static Coding OpcodeCodings254_38[]; + asmError Opcode254(x64Operand &operand); + static Coding OpcodeCodings255_38[]; + asmError Opcode255(x64Operand &operand); + static Coding OpcodeCodings256_38[]; + asmError Opcode256(x64Operand &operand); + static Coding OpcodeCodings257_38[]; + asmError Opcode257(x64Operand &operand); + static Coding OpcodeCodings258_38[]; + asmError Opcode258(x64Operand &operand); + static Coding OpcodeCodings259_19[]; + asmError Opcode259(x64Operand &operand); + static Coding OpcodeCodings260_36[]; + asmError Opcode260(x64Operand &operand); + static Coding OpcodeCodings261_36[]; + asmError Opcode261(x64Operand &operand); + static Coding OpcodeCodings262_36[]; + asmError Opcode262(x64Operand &operand); + static Coding OpcodeCodings263_19[]; + asmError Opcode263(x64Operand &operand); + static Coding OpcodeCodings264_36[]; + asmError Opcode264(x64Operand &operand); + static Coding OpcodeCodings265_19[]; + asmError Opcode265(x64Operand &operand); + static Coding OpcodeCodings266_36[]; + asmError Opcode266(x64Operand &operand); + static Coding OpcodeCodings267_18[]; + static Coding OpcodeCodings267_19[]; + asmError Opcode267(x64Operand &operand); + static Coding OpcodeCodings268_36[]; + asmError Opcode268(x64Operand &operand); + static Coding OpcodeCodings269_18[]; + static Coding OpcodeCodings269_19[]; + asmError Opcode269(x64Operand &operand); + static Coding OpcodeCodings270_18[]; + static Coding OpcodeCodings270_19[]; + asmError Opcode270(x64Operand &operand); + static Coding OpcodeCodings271_18[]; + static Coding OpcodeCodings271_19[]; + asmError Opcode271(x64Operand &operand); + asmError Opcode272(x64Operand &operand); + static Coding OpcodeCodings273_19[]; + asmError Opcode273(x64Operand &operand); + static Coding OpcodeCodings274_19[]; + asmError Opcode274(x64Operand &operand); + static Coding OpcodeCodings275_19[]; + asmError Opcode275(x64Operand &operand); + asmError Opcode276(x64Operand &operand); + asmError Opcode277(x64Operand &operand); + asmError Opcode278(x64Operand &operand); + asmError Opcode279(x64Operand &operand); + asmError Opcode280(x64Operand &operand); + asmError Opcode281(x64Operand &operand); + static Coding OpcodeCodings282_36[]; + asmError Opcode282(x64Operand &operand); + static Coding OpcodeCodings283_36[]; + asmError Opcode283(x64Operand &operand); + static Coding OpcodeCodings284_18[]; + static Coding OpcodeCodings284_19[]; + asmError Opcode284(x64Operand &operand); + asmError Opcode285(x64Operand &operand); + asmError Opcode286(x64Operand &operand); + static Coding OpcodeCodings287_36[]; + asmError Opcode287(x64Operand &operand); + static Coding OpcodeCodings288_19[]; + asmError Opcode288(x64Operand &operand); + static Coding OpcodeCodings289_19[]; + asmError Opcode289(x64Operand &operand); + asmError Opcode290(x64Operand &operand); + asmError Opcode291(x64Operand &operand); + static Coding OpcodeCodings292_36[]; + asmError Opcode292(x64Operand &operand); + static Coding OpcodeCodings293_36[]; + asmError Opcode293(x64Operand &operand); + asmError Opcode294(x64Operand &operand); + static Coding OpcodeCodings295_18[]; + asmError Opcode295(x64Operand &operand); + static Coding OpcodeCodings296_18[]; + asmError Opcode296(x64Operand &operand); + static Coding OpcodeCodings297_19[]; + asmError Opcode297(x64Operand &operand); + static Coding OpcodeCodings298_18[]; + asmError Opcode298(x64Operand &operand); + static Coding OpcodeCodings299_18[]; + static Coding OpcodeCodings299_36[]; + static Coding OpcodeCodings299_37[]; + asmError Opcode299(x64Operand &operand); + asmError Opcode300(x64Operand &operand); + asmError Opcode301(x64Operand &operand); + static Coding OpcodeCodings302_19[]; + asmError Opcode302(x64Operand &operand); + static Coding OpcodeCodings303_19[]; + asmError Opcode303(x64Operand &operand); + static Coding OpcodeCodings304_19[]; + asmError Opcode304(x64Operand &operand); + asmError Opcode305(x64Operand &operand); + static Coding OpcodeCodings306_19[]; + asmError Opcode306(x64Operand &operand); + static Coding OpcodeCodings307_19[]; + asmError Opcode307(x64Operand &operand); + static Coding OpcodeCodings308_19[]; + asmError Opcode308(x64Operand &operand); + static Coding OpcodeCodings309_23[]; + static Coding OpcodeCodings309_36[]; + asmError Opcode309(x64Operand &operand); + static Coding OpcodeCodings310_19[]; + asmError Opcode310(x64Operand &operand); + static Coding OpcodeCodings311_19[]; + asmError Opcode311(x64Operand &operand); + static Coding OpcodeCodings312_19[]; + asmError Opcode312(x64Operand &operand); + static Coding OpcodeCodings313_19[]; + asmError Opcode313(x64Operand &operand); + asmError Opcode314(x64Operand &operand); + asmError Opcode315(x64Operand &operand); + asmError Opcode316(x64Operand &operand); + asmError Opcode317(x64Operand &operand); + asmError Opcode318(x64Operand &operand); + static Coding OpcodeCodings319_19[]; + asmError Opcode319(x64Operand &operand); + static Coding OpcodeCodings320_19[]; + asmError Opcode320(x64Operand &operand); + static Coding OpcodeCodings321_19[]; + asmError Opcode321(x64Operand &operand); + static Coding OpcodeCodings322_19[]; + asmError Opcode322(x64Operand &operand); + static Coding OpcodeCodings323_19[]; + asmError Opcode323(x64Operand &operand); + static Coding OpcodeCodings324_19[]; + asmError Opcode324(x64Operand &operand); + static Coding OpcodeCodings325_19[]; + asmError Opcode325(x64Operand &operand); + static Coding OpcodeCodings326_18[]; + asmError Opcode326(x64Operand &operand); + static Coding OpcodeCodings327_18[]; + asmError Opcode327(x64Operand &operand); + static Coding OpcodeCodings328_19[]; + asmError Opcode328(x64Operand &operand); + static Coding OpcodeCodings329_19[]; + asmError Opcode329(x64Operand &operand); + static Coding OpcodeCodings330_19[]; + asmError Opcode330(x64Operand &operand); + asmError Opcode331(x64Operand &operand); + asmError Opcode332(x64Operand &operand); + static Coding OpcodeCodings333_18[]; + asmError Opcode333(x64Operand &operand); + static Coding OpcodeCodings334_18[]; + asmError Opcode334(x64Operand &operand); + static Coding OpcodeCodings335_19[]; + asmError Opcode335(x64Operand &operand); + static Coding OpcodeCodings336_19[]; + asmError Opcode336(x64Operand &operand); + static Coding OpcodeCodings337_18[]; + asmError Opcode337(x64Operand &operand); + static Coding OpcodeCodings338_18[]; + asmError Opcode338(x64Operand &operand); + static Coding OpcodeCodings339_18[]; + static Coding OpcodeCodings339_36[]; + static Coding OpcodeCodings339_37[]; + asmError Opcode339(x64Operand &operand); + asmError Opcode340(x64Operand &operand); + static Coding OpcodeCodings341_19[]; + asmError Opcode341(x64Operand &operand); + static Coding OpcodeCodings342_19[]; + asmError Opcode342(x64Operand &operand); + static Coding OpcodeCodings343_19[]; + asmError Opcode343(x64Operand &operand); + asmError Opcode344(x64Operand &operand); + static Coding OpcodeCodings345_38[]; + asmError Opcode345(x64Operand &operand); + static Coding OpcodeCodings346_38[]; + asmError Opcode346(x64Operand &operand); + static Coding OpcodeCodings347_38[]; + asmError Opcode347(x64Operand &operand); + static Coding OpcodeCodings348_38[]; + asmError Opcode348(x64Operand &operand); + static Coding OpcodeCodings349_38[]; + asmError Opcode349(x64Operand &operand); + static Coding OpcodeCodings350_38[]; + asmError Opcode350(x64Operand &operand); + static Coding OpcodeCodings351_38[]; + asmError Opcode351(x64Operand &operand); + static Coding OpcodeCodings352_38[]; + asmError Opcode352(x64Operand &operand); + static Coding OpcodeCodings353_38[]; + asmError Opcode353(x64Operand &operand); + static Coding OpcodeCodings354_38[]; + asmError Opcode354(x64Operand &operand); + static Coding OpcodeCodings355_38[]; + asmError Opcode355(x64Operand &operand); + static Coding OpcodeCodings356_38[]; + asmError Opcode356(x64Operand &operand); + static Coding OpcodeCodings357_38[]; + asmError Opcode357(x64Operand &operand); + static Coding OpcodeCodings358_38[]; + asmError Opcode358(x64Operand &operand); + static Coding OpcodeCodings359_38[]; + asmError Opcode359(x64Operand &operand); + static Coding OpcodeCodings360_38[]; + asmError Opcode360(x64Operand &operand); + static Coding OpcodeCodings361_38[]; + asmError Opcode361(x64Operand &operand); + static Coding OpcodeCodings362_38[]; + asmError Opcode362(x64Operand &operand); + static Coding OpcodeCodings363_38[]; + asmError Opcode363(x64Operand &operand); + static Coding OpcodeCodings364_38[]; + asmError Opcode364(x64Operand &operand); + static Coding OpcodeCodings365_38[]; + asmError Opcode365(x64Operand &operand); + static Coding OpcodeCodings366_38[]; + asmError Opcode366(x64Operand &operand); + static Coding OpcodeCodings367_38[]; + asmError Opcode367(x64Operand &operand); + static Coding OpcodeCodings368_38[]; + asmError Opcode368(x64Operand &operand); + static Coding OpcodeCodings369_38[]; + asmError Opcode369(x64Operand &operand); + static Coding OpcodeCodings370_38[]; + asmError Opcode370(x64Operand &operand); + static Coding OpcodeCodings371_38[]; + asmError Opcode371(x64Operand &operand); + static Coding OpcodeCodings372_38[]; + asmError Opcode372(x64Operand &operand); + static Coding OpcodeCodings373_38[]; + asmError Opcode373(x64Operand &operand); + static Coding OpcodeCodings374_38[]; + asmError Opcode374(x64Operand &operand); + static Coding OpcodeCodings375_19[]; + asmError Opcode375(x64Operand &operand); + static Coding OpcodeCodings376_18[]; + static Coding OpcodeCodings376_19[]; + asmError Opcode376(x64Operand &operand); + static Coding OpcodeCodings377_18[]; + asmError Opcode377(x64Operand &operand); + static Coding OpcodeCodings378_36[]; + asmError Opcode378(x64Operand &operand); + static Coding OpcodeCodings379_18[]; + asmError Opcode379(x64Operand &operand); + static Coding OpcodeCodings380_36[]; + asmError Opcode380(x64Operand &operand); + static Coding OpcodeCodings381_18[]; + static Coding OpcodeCodings381_19[]; + asmError Opcode381(x64Operand &operand); + static Coding OpcodeCodings382_18[]; + static Coding OpcodeCodings382_19[]; + asmError Opcode382(x64Operand &operand); + static Coding OpcodeCodings383_18[]; + static Coding OpcodeCodings383_19[]; + asmError Opcode383(x64Operand &operand); + static Coding OpcodeCodings384_19[]; + asmError Opcode384(x64Operand &operand); + static Coding OpcodeCodings385_19[]; + asmError Opcode385(x64Operand &operand); + static Coding OpcodeCodings386_19[]; + asmError Opcode386(x64Operand &operand); + asmError Opcode387(x64Operand &operand); + static Coding OpcodeCodings388_19[]; + asmError Opcode388(x64Operand &operand); + static Coding OpcodeCodings389_19[]; + asmError Opcode389(x64Operand &operand); + static Coding OpcodeCodings390_19[]; + asmError Opcode390(x64Operand &operand); + asmError Opcode391(x64Operand &operand); + static Coding OpcodeCodings392_18[]; + static Coding OpcodeCodings392_19[]; + asmError Opcode392(x64Operand &operand); + static Coding OpcodeCodings393_18[]; + static Coding OpcodeCodings393_36[]; + static Coding OpcodeCodings393_37[]; + asmError Opcode393(x64Operand &operand); + static Coding OpcodeCodings394_19[]; + asmError Opcode394(x64Operand &operand); + static Coding OpcodeCodings395_19[]; + asmError Opcode395(x64Operand &operand); + static Coding OpcodeCodings396_19[]; + asmError Opcode396(x64Operand &operand); + static Coding OpcodeCodings397_19[]; + asmError Opcode397(x64Operand &operand); + asmError Opcode398(x64Operand &operand); + static Coding OpcodeCodings399_19[]; + asmError Opcode399(x64Operand &operand); + static Coding OpcodeCodings400_18[]; + static Coding OpcodeCodings400_19[]; + asmError Opcode400(x64Operand &operand); + static Coding OpcodeCodings401_18[]; + static Coding OpcodeCodings401_19[]; + asmError Opcode401(x64Operand &operand); + static Coding OpcodeCodings402_19[]; + asmError Opcode402(x64Operand &operand); + static Coding OpcodeCodings403_19[]; + asmError Opcode403(x64Operand &operand); + static Coding OpcodeCodings404_19[]; + asmError Opcode404(x64Operand &operand); + asmError Opcode405(x64Operand &operand); + asmError Opcode406(x64Operand &operand); + asmError Opcode407(x64Operand &operand); + static Coding OpcodeCodings408_19[]; + asmError Opcode408(x64Operand &operand); + static Coding OpcodeCodings409_18[]; + static Coding OpcodeCodings409_36[]; + static Coding OpcodeCodings409_37[]; + asmError Opcode409(x64Operand &operand); + asmError Opcode410(x64Operand &operand); + asmError Opcode411(x64Operand &operand); + asmError Opcode412(x64Operand &operand); + asmError Opcode413(x64Operand &operand); + static Coding OpcodeCodings414_19[]; + asmError Opcode414(x64Operand &operand); + static Coding OpcodeCodings415_23[]; + static Coding OpcodeCodings415_19[]; + asmError Opcode415(x64Operand &operand); + static Coding OpcodeCodings416_23[]; + static Coding OpcodeCodings416_19[]; + asmError Opcode416(x64Operand &operand); + static Coding OpcodeCodings417_23[]; + static Coding OpcodeCodings417_19[]; + asmError Opcode417(x64Operand &operand); + static Coding OpcodeCodings418_23[]; + static Coding OpcodeCodings418_19[]; + asmError Opcode418(x64Operand &operand); + static Coding OpcodeCodings419_23[]; + static Coding OpcodeCodings419_19[]; + asmError Opcode419(x64Operand &operand); + static Coding OpcodeCodings420_23[]; + static Coding OpcodeCodings420_19[]; + asmError Opcode420(x64Operand &operand); + static Coding OpcodeCodings421_23[]; + static Coding OpcodeCodings421_19[]; + asmError Opcode421(x64Operand &operand); + static Coding OpcodeCodings422_23[]; + static Coding OpcodeCodings422_19[]; + asmError Opcode422(x64Operand &operand); + static Coding OpcodeCodings423_23[]; + static Coding OpcodeCodings423_19[]; + asmError Opcode423(x64Operand &operand); + static Coding OpcodeCodings424_23[]; + static Coding OpcodeCodings424_19[]; + asmError Opcode424(x64Operand &operand); + static Coding OpcodeCodings425_23[]; + static Coding OpcodeCodings425_19[]; + asmError Opcode425(x64Operand &operand); + static Coding OpcodeCodings426_23[]; + static Coding OpcodeCodings426_19[]; + asmError Opcode426(x64Operand &operand); + static Coding OpcodeCodings427_23[]; + static Coding OpcodeCodings427_19[]; + asmError Opcode427(x64Operand &operand); + static Coding OpcodeCodings428_23[]; + static Coding OpcodeCodings428_19[]; + asmError Opcode428(x64Operand &operand); + static Coding OpcodeCodings429_23[]; + static Coding OpcodeCodings429_19[]; + asmError Opcode429(x64Operand &operand); + static Coding OpcodeCodings430_23[]; + static Coding OpcodeCodings430_19[]; + asmError Opcode430(x64Operand &operand); + static Coding OpcodeCodings431_23[]; + static Coding OpcodeCodings431_19[]; + asmError Opcode431(x64Operand &operand); + static Coding OpcodeCodings432_23[]; + static Coding OpcodeCodings432_19[]; + asmError Opcode432(x64Operand &operand); + static Coding OpcodeCodings433_23[]; + static Coding OpcodeCodings433_19[]; + asmError Opcode433(x64Operand &operand); + static Coding OpcodeCodings434_23[]; + static Coding OpcodeCodings434_19[]; + asmError Opcode434(x64Operand &operand); + static Coding OpcodeCodings435_23[]; + static Coding OpcodeCodings435_19[]; + asmError Opcode435(x64Operand &operand); + static Coding OpcodeCodings436_23[]; + static Coding OpcodeCodings436_19[]; + asmError Opcode436(x64Operand &operand); + static Coding OpcodeCodings437_23[]; + static Coding OpcodeCodings437_19[]; + asmError Opcode437(x64Operand &operand); + static Coding OpcodeCodings438_23[]; + static Coding OpcodeCodings438_19[]; + asmError Opcode438(x64Operand &operand); + static Coding OpcodeCodings439_23[]; + static Coding OpcodeCodings439_19[]; + asmError Opcode439(x64Operand &operand); + static Coding OpcodeCodings440_23[]; + static Coding OpcodeCodings440_19[]; + asmError Opcode440(x64Operand &operand); + static Coding OpcodeCodings441_23[]; + static Coding OpcodeCodings441_19[]; + asmError Opcode441(x64Operand &operand); + static Coding OpcodeCodings442_23[]; + static Coding OpcodeCodings442_19[]; + asmError Opcode442(x64Operand &operand); + static Coding OpcodeCodings443_23[]; + static Coding OpcodeCodings443_19[]; + asmError Opcode443(x64Operand &operand); + static Coding OpcodeCodings444_23[]; + static Coding OpcodeCodings444_19[]; + asmError Opcode444(x64Operand &operand); + static Coding OpcodeCodings445_23[]; + static Coding OpcodeCodings445_19[]; + asmError Opcode445(x64Operand &operand); + static Coding OpcodeCodings446_23[]; + static Coding OpcodeCodings446_19[]; + asmError Opcode446(x64Operand &operand); + static Coding OpcodeCodings447_23[]; + static Coding OpcodeCodings447_19[]; + asmError Opcode447(x64Operand &operand); + static Coding OpcodeCodings448_23[]; + static Coding OpcodeCodings448_19[]; + asmError Opcode448(x64Operand &operand); + static Coding OpcodeCodings449_23[]; + static Coding OpcodeCodings449_19[]; + asmError Opcode449(x64Operand &operand); + static Coding OpcodeCodings450_23[]; + static Coding OpcodeCodings450_19[]; + asmError Opcode450(x64Operand &operand); + static Coding OpcodeCodings451_23[]; + static Coding OpcodeCodings451_19[]; + asmError Opcode451(x64Operand &operand); + static Coding OpcodeCodings452_23[]; + static Coding OpcodeCodings452_19[]; + asmError Opcode452(x64Operand &operand); + static Coding OpcodeCodings453_23[]; + static Coding OpcodeCodings453_19[]; + asmError Opcode453(x64Operand &operand); + static Coding OpcodeCodings454_23[]; + static Coding OpcodeCodings454_19[]; + asmError Opcode454(x64Operand &operand); + static Coding OpcodeCodings455_23[]; + static Coding OpcodeCodings455_19[]; + asmError Opcode455(x64Operand &operand); + static Coding OpcodeCodings456_23[]; + static Coding OpcodeCodings456_19[]; + asmError Opcode456(x64Operand &operand); + static Coding OpcodeCodings457_23[]; + static Coding OpcodeCodings457_19[]; + asmError Opcode457(x64Operand &operand); + static Coding OpcodeCodings458_23[]; + static Coding OpcodeCodings458_19[]; + asmError Opcode458(x64Operand &operand); + static Coding OpcodeCodings459_23[]; + static Coding OpcodeCodings459_19[]; + asmError Opcode459(x64Operand &operand); + static Coding OpcodeCodings460_23[]; + static Coding OpcodeCodings460_19[]; + asmError Opcode460(x64Operand &operand); + static Coding OpcodeCodings461_23[]; + static Coding OpcodeCodings461_19[]; + asmError Opcode461(x64Operand &operand); + static Coding OpcodeCodings462_23[]; + static Coding OpcodeCodings462_19[]; + asmError Opcode462(x64Operand &operand); + asmError Opcode463(x64Operand &operand); + asmError Opcode464(x64Operand &operand); + static Coding OpcodeCodings465_23[]; + static Coding OpcodeCodings465_19[]; + asmError Opcode465(x64Operand &operand); + static Coding OpcodeCodings466_23[]; + static Coding OpcodeCodings466_19[]; + asmError Opcode466(x64Operand &operand); + static Coding OpcodeCodings467_23[]; + static Coding OpcodeCodings467_19[]; + asmError Opcode467(x64Operand &operand); + static Coding OpcodeCodings468_23[]; + static Coding OpcodeCodings468_19[]; + asmError Opcode468(x64Operand &operand); + static Coding OpcodeCodings469_19[]; + asmError Opcode469(x64Operand &operand); + static Coding OpcodeCodings470_19[]; + asmError Opcode470(x64Operand &operand); + static Coding OpcodeCodings471_23[]; + static Coding OpcodeCodings471_19[]; + asmError Opcode471(x64Operand &operand); + static Coding OpcodeCodings472_23[]; + static Coding OpcodeCodings472_19[]; + asmError Opcode472(x64Operand &operand); + static Coding OpcodeCodings473_23[]; + static Coding OpcodeCodings473_19[]; + asmError Opcode473(x64Operand &operand); + static Coding OpcodeCodings474_23[]; + static Coding OpcodeCodings474_19[]; + asmError Opcode474(x64Operand &operand); + static Coding OpcodeCodings475_19[]; + asmError Opcode475(x64Operand &operand); + static Coding OpcodeCodings476_23[]; + static Coding OpcodeCodings476_36[]; + asmError Opcode476(x64Operand &operand); + static Coding OpcodeCodings477_23[]; + static Coding OpcodeCodings477_36[]; + asmError Opcode477(x64Operand &operand); + asmError Opcode478(x64Operand &operand); + asmError Opcode479(x64Operand &operand); + static Coding OpcodeCodings480_23[]; + static Coding OpcodeCodings480_19[]; + asmError Opcode480(x64Operand &operand); + static Coding OpcodeCodings481_23[]; + static Coding OpcodeCodings481_19[]; + asmError Opcode481(x64Operand &operand); + static Coding OpcodeCodings482_23[]; + static Coding OpcodeCodings482_36[]; + asmError Opcode482(x64Operand &operand); + static Coding OpcodeCodings483_23[]; + static Coding OpcodeCodings483_36[]; + asmError Opcode483(x64Operand &operand); + asmError Opcode484(x64Operand &operand); + static Coding OpcodeCodings485_23[]; + static Coding OpcodeCodings485_36[]; + asmError Opcode485(x64Operand &operand); + static Coding OpcodeCodings486_23[]; + static Coding OpcodeCodings486_36[]; + asmError Opcode486(x64Operand &operand); + asmError Opcode487(x64Operand &operand); + static Coding OpcodeCodings488_23[]; + static Coding OpcodeCodings488_36[]; + asmError Opcode488(x64Operand &operand); + static Coding OpcodeCodings489_23[]; + static Coding OpcodeCodings489_36[]; + asmError Opcode489(x64Operand &operand); + static Coding OpcodeCodings490_23[]; + static Coding OpcodeCodings490_19[]; + asmError Opcode490(x64Operand &operand); + static Coding OpcodeCodings491_23[]; + static Coding OpcodeCodings491_19[]; + asmError Opcode491(x64Operand &operand); + asmError Opcode492(x64Operand &operand); + static Coding OpcodeCodings493_19[]; + asmError Opcode493(x64Operand &operand); + asmError Opcode494(x64Operand &operand); + asmError Opcode495(x64Operand &operand); + asmError Opcode496(x64Operand &operand); + asmError Opcode497(x64Operand &operand); + static Coding OpcodeCodings498_23[]; + static Coding OpcodeCodings498_19[]; + asmError Opcode498(x64Operand &operand); + static Coding OpcodeCodings499_23[]; + static Coding OpcodeCodings499_19[]; + asmError Opcode499(x64Operand &operand); + static Coding OpcodeCodings500_23[]; + static Coding OpcodeCodings500_36[]; + asmError Opcode500(x64Operand &operand); + static Coding OpcodeCodings501_23[]; + static Coding OpcodeCodings501_36[]; + asmError Opcode501(x64Operand &operand); + static Coding OpcodeCodings502_23[]; + static Coding OpcodeCodings502_36[]; + asmError Opcode502(x64Operand &operand); + static Coding OpcodeCodings503_23[]; + static Coding OpcodeCodings503_19[]; + asmError Opcode503(x64Operand &operand); + static Coding OpcodeCodings504_23[]; + static Coding OpcodeCodings504_19[]; + asmError Opcode504(x64Operand &operand); + static Coding OpcodeCodings505_23[]; + static Coding OpcodeCodings505_19[]; + asmError Opcode505(x64Operand &operand); + static Coding OpcodeCodings506_23[]; + static Coding OpcodeCodings506_19[]; + asmError Opcode506(x64Operand &operand); + static Coding OpcodeCodings507_23[]; + static Coding OpcodeCodings507_19[]; + asmError Opcode507(x64Operand &operand); + static Coding OpcodeCodings508_23[]; + static Coding OpcodeCodings508_19[]; + asmError Opcode508(x64Operand &operand); + static Coding OpcodeCodings509_23[]; + static Coding OpcodeCodings509_19[]; + asmError Opcode509(x64Operand &operand); + static Coding OpcodeCodings510_19[]; + asmError Opcode510(x64Operand &operand); + static Coding OpcodeCodings511_19[]; + asmError Opcode511(x64Operand &operand); + static Coding OpcodeCodings512_23[]; + static Coding OpcodeCodings512_19[]; + asmError Opcode512(x64Operand &operand); + static Coding OpcodeCodings513_19[]; + asmError Opcode513(x64Operand &operand); + static Coding OpcodeCodings514_19[]; + asmError Opcode514(x64Operand &operand); + static Coding OpcodeCodings515_19[]; + asmError Opcode515(x64Operand &operand); + static Coding OpcodeCodings516_19[]; + asmError Opcode516(x64Operand &operand); + static Coding OpcodeCodings517_19[]; + asmError Opcode517(x64Operand &operand); + static Coding OpcodeCodings518_19[]; + asmError Opcode518(x64Operand &operand); + static Coding OpcodeCodings519_19[]; + asmError Opcode519(x64Operand &operand); + static Coding OpcodeCodings520_19[]; + asmError Opcode520(x64Operand &operand); + static Coding OpcodeCodings521_19[]; + asmError Opcode521(x64Operand &operand); + static Coding OpcodeCodings522_19[]; + asmError Opcode522(x64Operand &operand); + static Coding OpcodeCodings523_19[]; + asmError Opcode523(x64Operand &operand); + static Coding OpcodeCodings524_19[]; + asmError Opcode524(x64Operand &operand); + static Coding OpcodeCodings525_23[]; + static Coding OpcodeCodings525_19[]; + asmError Opcode525(x64Operand &operand); + static Coding OpcodeCodings526_19[]; + asmError Opcode526(x64Operand &operand); + static Coding OpcodeCodings527_19[]; + asmError Opcode527(x64Operand &operand); + static Coding OpcodeCodings528_19[]; + asmError Opcode528(x64Operand &operand); + static Coding OpcodeCodings529_23[]; + static Coding OpcodeCodings529_19[]; + asmError Opcode529(x64Operand &operand); + static Coding OpcodeCodings530_23[]; + static Coding OpcodeCodings530_19[]; + asmError Opcode530(x64Operand &operand); + static Coding OpcodeCodings531_19[]; + asmError Opcode531(x64Operand &operand); + static Coding OpcodeCodings532_19[]; + asmError Opcode532(x64Operand &operand); + static Coding OpcodeCodings533_19[]; + asmError Opcode533(x64Operand &operand); + static Coding OpcodeCodings534_19[]; + asmError Opcode534(x64Operand &operand); + static Coding OpcodeCodings535_19[]; + asmError Opcode535(x64Operand &operand); + static Coding OpcodeCodings536_19[]; + asmError Opcode536(x64Operand &operand); + asmError Opcode537(x64Operand &operand); + static Coding OpcodeCodings538_19[]; + asmError Opcode538(x64Operand &operand); + static Coding OpcodeCodings539_19[]; + asmError Opcode539(x64Operand &operand); + static Coding OpcodeCodings540_19[]; + asmError Opcode540(x64Operand &operand); + asmError Opcode541(x64Operand &operand); + static Coding OpcodeCodings542_19[]; + asmError Opcode542(x64Operand &operand); + static Coding OpcodeCodings543_19[]; + asmError Opcode543(x64Operand &operand); + static Coding OpcodeCodings544_19[]; + asmError Opcode544(x64Operand &operand); + static Coding OpcodeCodings545_19[]; + asmError Opcode545(x64Operand &operand); + static Coding OpcodeCodings546_19[]; + asmError Opcode546(x64Operand &operand); + static Coding OpcodeCodings547_19[]; + asmError Opcode547(x64Operand &operand); + static Coding OpcodeCodings548_19[]; + asmError Opcode548(x64Operand &operand); + static Coding OpcodeCodings549_19[]; + asmError Opcode549(x64Operand &operand); + static Coding OpcodeCodings550_19[]; + asmError Opcode550(x64Operand &operand); + static Coding OpcodeCodings551_19[]; + asmError Opcode551(x64Operand &operand); + static Coding OpcodeCodings552_19[]; + asmError Opcode552(x64Operand &operand); + static Coding OpcodeCodings553_23[]; + static Coding OpcodeCodings553_19[]; + asmError Opcode553(x64Operand &operand); + static Coding OpcodeCodings554_23[]; + static Coding OpcodeCodings554_19[]; + asmError Opcode554(x64Operand &operand); + static Coding OpcodeCodings555_23[]; + static Coding OpcodeCodings555_19[]; + asmError Opcode555(x64Operand &operand); + static Coding OpcodeCodings556_23[]; + static Coding OpcodeCodings556_19[]; + asmError Opcode556(x64Operand &operand); + static Coding OpcodeCodings557_39[]; + static Coding OpcodeCodings557_36[]; + static Coding OpcodeCodings557_37[]; + asmError Opcode557(x64Operand &operand); + static Coding OpcodeCodings558_23[]; + static Coding OpcodeCodings558_19[]; + asmError Opcode558(x64Operand &operand); + static Coding OpcodeCodings559_39[]; + static Coding OpcodeCodings559_36[]; + static Coding OpcodeCodings559_37[]; + asmError Opcode559(x64Operand &operand); + static Coding OpcodeCodings560_39[]; + static Coding OpcodeCodings560_36[]; + static Coding OpcodeCodings560_37[]; + asmError Opcode560(x64Operand &operand); + static Coding OpcodeCodings561_39[]; + static Coding OpcodeCodings561_36[]; + static Coding OpcodeCodings561_37[]; + asmError Opcode561(x64Operand &operand); + static Coding OpcodeCodings562_39[]; + static Coding OpcodeCodings562_36[]; + static Coding OpcodeCodings562_37[]; + asmError Opcode562(x64Operand &operand); + static Coding OpcodeCodings563_39[]; + static Coding OpcodeCodings563_36[]; + static Coding OpcodeCodings563_37[]; + asmError Opcode563(x64Operand &operand); + static Coding OpcodeCodings564_23[]; + static Coding OpcodeCodings564_19[]; + asmError Opcode564(x64Operand &operand); + static Coding OpcodeCodings565_39[]; + static Coding OpcodeCodings565_36[]; + static Coding OpcodeCodings565_37[]; + asmError Opcode565(x64Operand &operand); + static Coding OpcodeCodings566_39[]; + static Coding OpcodeCodings566_36[]; + static Coding OpcodeCodings566_37[]; + asmError Opcode566(x64Operand &operand); + static Coding OpcodeCodings567_19[]; + asmError Opcode567(x64Operand &operand); + static Coding OpcodeCodings568_19[]; + asmError Opcode568(x64Operand &operand); + static Coding OpcodeCodings569_19[]; + asmError Opcode569(x64Operand &operand); + static Coding OpcodeCodings570_19[]; + asmError Opcode570(x64Operand &operand); + static Coding OpcodeCodings571_19[]; + asmError Opcode571(x64Operand &operand); + static Coding OpcodeCodings572_19[]; + asmError Opcode572(x64Operand &operand); + static Coding OpcodeCodings573_19[]; + asmError Opcode573(x64Operand &operand); + static Coding OpcodeCodings574_19[]; + asmError Opcode574(x64Operand &operand); + static Coding OpcodeCodings575_19[]; + asmError Opcode575(x64Operand &operand); + static Coding OpcodeCodings576_23[]; + static Coding OpcodeCodings576_19[]; + asmError Opcode576(x64Operand &operand); + static Coding OpcodeCodings577_19[]; + asmError Opcode577(x64Operand &operand); + static Coding OpcodeCodings578_19[]; + asmError Opcode578(x64Operand &operand); + static Coding OpcodeCodings579_19[]; + asmError Opcode579(x64Operand &operand); + static Coding OpcodeCodings580_23[]; + static Coding OpcodeCodings580_19[]; + asmError Opcode580(x64Operand &operand); + static Coding OpcodeCodings581_19[]; + asmError Opcode581(x64Operand &operand); + static Coding OpcodeCodings582_19[]; + asmError Opcode582(x64Operand &operand); + static Coding OpcodeCodings583_23[]; + static Coding OpcodeCodings583_19[]; + asmError Opcode583(x64Operand &operand); + static Coding OpcodeCodings584_23[]; + static Coding OpcodeCodings584_19[]; + asmError Opcode584(x64Operand &operand); + static Coding OpcodeCodings585_23[]; + static Coding OpcodeCodings585_19[]; + asmError Opcode585(x64Operand &operand); + static Coding OpcodeCodings586_23[]; + static Coding OpcodeCodings586_19[]; + asmError Opcode586(x64Operand &operand); + static Coding OpcodeCodings587_23[]; + static Coding OpcodeCodings587_19[]; + asmError Opcode587(x64Operand &operand); + static Coding OpcodeCodings588_23[]; + static Coding OpcodeCodings588_19[]; + asmError Opcode588(x64Operand &operand); + static Coding OpcodeCodings589_23[]; + static Coding OpcodeCodings589_19[]; + asmError Opcode589(x64Operand &operand); + static Coding OpcodeCodings590_23[]; + static Coding OpcodeCodings590_19[]; + asmError Opcode590(x64Operand &operand); + static Coding OpcodeCodings591_23[]; + static Coding OpcodeCodings591_19[]; + asmError Opcode591(x64Operand &operand); + static Coding OpcodeCodings592_23[]; + static Coding OpcodeCodings592_19[]; + asmError Opcode592(x64Operand &operand); + static Coding OpcodeCodings593_23[]; + static Coding OpcodeCodings593_19[]; + asmError Opcode593(x64Operand &operand); + static Coding OpcodeCodings594_23[]; + static Coding OpcodeCodings594_19[]; + asmError Opcode594(x64Operand &operand); + static Coding OpcodeCodings595_23[]; + static Coding OpcodeCodings595_19[]; + asmError Opcode595(x64Operand &operand); + static Coding OpcodeCodings596_23[]; + static Coding OpcodeCodings596_19[]; + asmError Opcode596(x64Operand &operand); + static Coding OpcodeCodings597_23[]; + static Coding OpcodeCodings597_19[]; + asmError Opcode597(x64Operand &operand); + static Coding OpcodeCodings598_23[]; + static Coding OpcodeCodings598_19[]; + asmError Opcode598(x64Operand &operand); + static Coding OpcodeCodings599_23[]; + static Coding OpcodeCodings599_19[]; + asmError Opcode599(x64Operand &operand); + static Coding OpcodeCodings600_23[]; + static Coding OpcodeCodings600_19[]; + asmError Opcode600(x64Operand &operand); + static Coding OpcodeCodings601_23[]; + static Coding OpcodeCodings601_19[]; + asmError Opcode601(x64Operand &operand); + static Coding OpcodeCodings602_23[]; + static Coding OpcodeCodings602_19[]; + asmError Opcode602(x64Operand &operand); + static Coding OpcodeCodings603_23[]; + static Coding OpcodeCodings603_19[]; + asmError Opcode603(x64Operand &operand); + static Coding OpcodeCodings604_23[]; + static Coding OpcodeCodings604_19[]; + asmError Opcode604(x64Operand &operand); + static Coding OpcodeCodings605_23[]; + static Coding OpcodeCodings605_19[]; + asmError Opcode605(x64Operand &operand); + static Coding OpcodeCodings606_23[]; + static Coding OpcodeCodings606_19[]; + asmError Opcode606(x64Operand &operand); + static Coding OpcodeCodings607_23[]; + static Coding OpcodeCodings607_19[]; + asmError Opcode607(x64Operand &operand); + static Coding OpcodeCodings608_23[]; + static Coding OpcodeCodings608_19[]; + asmError Opcode608(x64Operand &operand); + asmError Opcode609(x64Operand &operand); + asmError Opcode610(x64Operand &operand); + asmError Opcode611(x64Operand &operand); + asmError Opcode612(x64Operand &operand); + asmError Opcode613(x64Operand &operand); + asmError Opcode614(x64Operand &operand); + asmError Opcode615(x64Operand &operand); + asmError Opcode616(x64Operand &operand); + asmError Opcode617(x64Operand &operand); + asmError Opcode618(x64Operand &operand); + asmError Opcode619(x64Operand &operand); + asmError Opcode620(x64Operand &operand); - static Coding Coding1[]; - static Coding Coding2[]; - static Coding Coding3[]; - static Coding Coding4[]; - static Coding Coding5[]; - static Coding Coding6[]; - static Coding Coding7[]; - static Coding Coding8[]; - static Coding Coding9[]; - static Coding Coding10[]; - static Coding Coding11[]; - static Coding Coding12[]; - static Coding Coding13[]; - static Coding Coding14[]; - static Coding Coding15[]; - static Coding Coding16[]; - static Coding Coding17[]; - static Coding Coding18[]; - static Coding Coding19[]; - static Coding Coding20[]; - static Coding Coding21[]; - static Coding Coding22[]; - static Coding Coding23[]; - static Coding Coding24[]; - static Coding Coding25[]; - static Coding Coding26[]; - static Coding Coding27[]; - static Coding Coding28[]; - static Coding Coding29[]; - static Coding Coding30[]; - static Coding Coding31[]; - static Coding Coding32[]; - static Coding Coding33[]; - static Coding Coding34[]; - static Coding Coding35[]; - static Coding Coding36[]; - static Coding Coding37[]; - static Coding Coding38[]; - static Coding Coding39[]; - static Coding Coding40[]; - static Coding Coding41[]; - static Coding Coding42[]; - static Coding Coding43[]; - static Coding Coding44[]; - static Coding Coding45[]; - static Coding Coding46[]; - static Coding Coding47[]; - static Coding Coding48[]; - static Coding Coding49[]; - static Coding Coding50[]; - static Coding Coding51[]; - static Coding Coding52[]; - static Coding Coding53[]; - static Coding Coding54[]; - static Coding Coding55[]; - static Coding Coding56[]; - static Coding Coding57[]; - static Coding Coding58[]; - static Coding Coding59[]; - static Coding Coding60[]; - static Coding Coding61[]; - static Coding Coding62[]; - static Coding Coding63[]; - static Coding Coding64[]; - static Coding Coding65[]; - static Coding Coding66[]; - static Coding Coding67[]; - static Coding Coding68[]; - static Coding Coding69[]; - static Coding Coding70[]; - static Coding Coding71[]; - static Coding Coding72[]; - static Coding Coding73[]; - static Coding Coding74[]; - static Coding Coding75[]; - static Coding Coding76[]; - static Coding Coding77[]; - static Coding Coding78[]; - static Coding Coding79[]; - static Coding Coding80[]; - static Coding Coding81[]; - static Coding Coding82[]; - static Coding Coding83[]; - static Coding Coding84[]; - static Coding Coding85[]; - static Coding Coding86[]; - static Coding Coding87[]; - static Coding Coding88[]; - static Coding Coding89[]; - static Coding Coding90[]; - static Coding Coding91[]; - static Coding Coding92[]; - static Coding Coding93[]; - static Coding Coding94[]; - static Coding Coding95[]; - static Coding Coding96[]; - static Coding Coding97[]; - static Coding Coding98[]; - static Coding Coding99[]; - static Coding Coding100[]; - static Coding Coding101[]; - static Coding Coding102[]; - static Coding Coding103[]; - static Coding Coding104[]; - static Coding Coding105[]; - static Coding Coding106[]; - static Coding Coding107[]; - static Coding Coding108[]; - static Coding Coding109[]; - static Coding Coding110[]; - static Coding Coding111[]; - static Coding Coding112[]; - static Coding Coding113[]; - static Coding Coding114[]; - static Coding Coding115[]; - static Coding Coding116[]; - static Coding Coding117[]; - static Coding Coding118[]; - static Coding Coding119[]; - static Coding Coding120[]; - static Coding Coding121[]; - static Coding Coding122[]; - static Coding Coding123[]; - static Coding Coding124[]; - static Coding Coding125[]; - static Coding Coding126[]; - static Coding Coding127[]; - static Coding Coding128[]; - static Coding Coding129[]; - static Coding Coding130[]; - static Coding Coding131[]; - static Coding Coding132[]; - static Coding Coding133[]; - static Coding Coding134[]; - static Coding Coding135[]; - static Coding Coding136[]; - static Coding Coding137[]; - static Coding Coding138[]; - static Coding Coding139[]; - static Coding Coding140[]; - static Coding Coding141[]; - static Coding Coding142[]; - static Coding Coding143[]; - static Coding Coding144[]; - static Coding Coding145[]; - static Coding Coding146[]; - static Coding Coding147[]; - static Coding Coding148[]; - static Coding Coding149[]; - static Coding Coding150[]; - static Coding Coding151[]; - static Coding Coding152[]; - static Coding Coding153[]; - static Coding Coding154[]; - static Coding Coding155[]; - static Coding Coding156[]; - static Coding Coding157[]; - static Coding Coding158[]; - static Coding Coding159[]; - static Coding Coding160[]; - static Coding Coding161[]; - static Coding Coding162[]; - static Coding Coding163[]; - static Coding Coding164[]; - static Coding Coding165[]; - static Coding Coding166[]; - static Coding Coding167[]; - static Coding Coding168[]; - static Coding Coding169[]; - static Coding Coding170[]; - static Coding Coding171[]; - static Coding Coding172[]; - static Coding Coding173[]; - static Coding Coding174[]; - static Coding Coding175[]; - static Coding Coding176[]; - static Coding Coding177[]; - static Coding Coding178[]; - static Coding Coding179[]; - static Coding Coding180[]; - static Coding Coding181[]; - static Coding Coding182[]; - static Coding Coding183[]; - static Coding Coding184[]; - static Coding Coding185[]; - static Coding Coding186[]; - static Coding Coding187[]; - static Coding Coding188[]; - static Coding Coding189[]; - static Coding Coding190[]; - static Coding Coding191[]; - static Coding Coding192[]; - static Coding Coding193[]; - static Coding Coding194[]; - static Coding Coding195[]; - static Coding Coding196[]; - static Coding Coding197[]; - static Coding Coding198[]; - static Coding Coding199[]; - static Coding Coding200[]; - static Coding Coding201[]; - static Coding Coding202[]; - static Coding Coding203[]; - static Coding Coding204[]; - static Coding Coding205[]; - static Coding Coding206[]; - static Coding Coding207[]; - static Coding Coding208[]; - static Coding Coding209[]; - static Coding Coding210[]; - static Coding Coding211[]; - static Coding Coding212[]; - static Coding Coding213[]; - static Coding Coding214[]; - static Coding Coding215[]; - static Coding Coding216[]; - static Coding Coding217[]; - static Coding Coding218[]; - static Coding Coding219[]; - static Coding Coding220[]; - static Coding Coding221[]; - static Coding Coding222[]; - static Coding Coding223[]; - static Coding Coding224[]; - static Coding Coding225[]; - static Coding Coding226[]; - static Coding Coding227[]; - static Coding Coding228[]; - static Coding Coding229[]; - static Coding Coding230[]; - static Coding Coding231[]; - static Coding Coding232[]; - static Coding Coding233[]; - static Coding Coding234[]; - static Coding Coding235[]; - static Coding Coding236[]; - static Coding Coding237[]; - static Coding Coding238[]; - static Coding Coding239[]; - static Coding Coding240[]; - static Coding Coding241[]; - static Coding Coding242[]; - static Coding Coding243[]; - static Coding Coding244[]; - static Coding Coding245[]; - static Coding Coding246[]; - static Coding Coding247[]; - static Coding Coding248[]; - static Coding Coding249[]; - static Coding Coding250[]; - static Coding Coding251[]; - static Coding Coding252[]; - static Coding Coding253[]; - static Coding Coding254[]; - static Coding Coding255[]; - static Coding Coding256[]; - static Coding Coding257[]; - static Coding Coding258[]; - static Coding Coding259[]; - static Coding Coding260[]; - static Coding Coding261[]; - static Coding Coding262[]; - static Coding Coding263[]; - static Coding Coding264[]; - static Coding Coding265[]; - static Coding Coding266[]; - static Coding Coding267[]; - static Coding Coding268[]; - static Coding Coding269[]; - static Coding Coding270[]; - static Coding Coding271[]; - static Coding Coding272[]; - static Coding Coding273[]; - static Coding Coding274[]; - static Coding Coding275[]; - static Coding Coding276[]; - static Coding Coding277[]; - static Coding Coding278[]; - static Coding Coding279[]; - static Coding Coding280[]; - static Coding Coding281[]; - static Coding Coding282[]; - static Coding Coding283[]; - static Coding Coding284[]; - static Coding Coding285[]; - static Coding Coding286[]; - static Coding Coding287[]; - static Coding Coding288[]; - static Coding Coding289[]; - static Coding Coding290[]; - static Coding Coding291[]; - static Coding Coding292[]; - static Coding Coding293[]; - static Coding Coding294[]; - static Coding Coding295[]; - static Coding Coding296[]; - static Coding Coding297[]; - static Coding Coding298[]; - static Coding Coding299[]; - static Coding Coding300[]; - static Coding Coding301[]; - static Coding Coding302[]; - static Coding Coding303[]; - static Coding Coding304[]; - static Coding Coding305[]; - static Coding Coding306[]; - static Coding Coding307[]; - static Coding Coding308[]; - static Coding Coding309[]; - static Coding Coding310[]; - static Coding Coding311[]; - static Coding Coding312[]; - static Coding Coding313[]; - static Coding Coding314[]; - static Coding Coding315[]; - static Coding Coding316[]; - static Coding Coding317[]; - static Coding Coding318[]; - static Coding Coding319[]; - static Coding Coding320[]; - static Coding Coding321[]; - static Coding Coding322[]; - static Coding Coding323[]; - static Coding Coding324[]; - static Coding Coding325[]; - static Coding Coding326[]; - static Coding Coding327[]; - static Coding Coding328[]; - static Coding Coding329[]; - static Coding Coding330[]; - static Coding Coding331[]; - static Coding Coding332[]; - static Coding Coding333[]; - static Coding Coding334[]; - static Coding Coding335[]; - static Coding Coding336[]; - static Coding Coding337[]; - static Coding Coding338[]; - static Coding Coding339[]; - static Coding Coding340[]; - static Coding Coding341[]; - static Coding Coding342[]; - static Coding Coding343[]; - static Coding Coding344[]; - static Coding Coding345[]; - static Coding Coding346[]; - static Coding Coding347[]; - static Coding Coding348[]; - static Coding Coding349[]; - static Coding Coding350[]; - static Coding Coding351[]; - static Coding Coding352[]; - static Coding Coding353[]; - static Coding Coding354[]; - static Coding Coding355[]; - static Coding Coding356[]; - static Coding Coding357[]; - static Coding Coding358[]; - static Coding Coding359[]; - static Coding Coding360[]; - static Coding Coding361[]; - static Coding Coding362[]; - static Coding Coding363[]; - static Coding Coding364[]; - static Coding Coding365[]; - static Coding Coding366[]; - static Coding Coding367[]; - static Coding Coding368[]; - static Coding Coding369[]; - static Coding Coding370[]; - static Coding Coding371[]; - static Coding Coding372[]; - static Coding Coding373[]; - static Coding Coding374[]; - static Coding Coding375[]; - static Coding Coding376[]; - static Coding Coding377[]; - static Coding Coding378[]; - static Coding Coding379[]; - static Coding Coding380[]; - static Coding Coding381[]; - static Coding Coding382[]; - static Coding Coding383[]; - static Coding Coding384[]; - static Coding Coding385[]; - static Coding Coding386[]; - static Coding Coding387[]; - static Coding Coding388[]; - static Coding Coding389[]; - static Coding Coding390[]; - static Coding Coding391[]; - static Coding Coding392[]; - static Coding Coding393[]; - static Coding Coding394[]; - static Coding Coding395[]; - static Coding Coding396[]; - static Coding Coding397[]; - static Coding Coding398[]; - static Coding Coding399[]; - static Coding Coding400[]; - static Coding Coding401[]; - static Coding Coding402[]; - static Coding Coding403[]; - static Coding Coding404[]; - static Coding Coding405[]; - static Coding Coding406[]; - static Coding Coding407[]; - static Coding Coding408[]; - static Coding Coding409[]; - static Coding Coding410[]; - static Coding Coding411[]; - static Coding Coding412[]; - static Coding Coding413[]; - static Coding Coding414[]; - static Coding Coding415[]; - static Coding Coding416[]; - static Coding Coding417[]; - static Coding Coding418[]; - static Coding Coding419[]; - static Coding Coding420[]; - static Coding Coding421[]; - static Coding Coding422[]; - static Coding Coding423[]; - static Coding Coding424[]; - static Coding Coding425[]; - static Coding Coding426[]; - static Coding Coding427[]; - static Coding Coding428[]; - static Coding Coding429[]; - static Coding Coding430[]; - static Coding Coding431[]; - static Coding Coding432[]; - static Coding Coding433[]; - static Coding Coding434[]; - static Coding Coding435[]; - static Coding Coding436[]; - static Coding Coding437[]; - static Coding Coding438[]; - static Coding Coding439[]; - static Coding Coding440[]; - static Coding Coding441[]; - static Coding Coding442[]; - static Coding Coding443[]; - static Coding Coding444[]; - static Coding Coding445[]; - static Coding Coding446[]; - static Coding Coding447[]; - static Coding Coding448[]; - static Coding Coding449[]; - static Coding Coding450[]; - static Coding Coding451[]; - static Coding Coding452[]; - static Coding Coding453[]; - static Coding Coding454[]; - static Coding Coding455[]; - static Coding Coding456[]; - static Coding Coding457[]; - static Coding Coding458[]; - static Coding Coding459[]; - static Coding Coding460[]; - static Coding Coding461[]; - static Coding Coding462[]; - static Coding Coding463[]; - static Coding Coding464[]; - static Coding Coding465[]; - static Coding Coding466[]; - static Coding Coding467[]; - static Coding Coding468[]; - static Coding Coding469[]; - static Coding Coding470[]; - static Coding Coding471[]; - static Coding Coding472[]; - static Coding Coding473[]; - static Coding Coding474[]; - static Coding Coding475[]; - static Coding Coding476[]; - static Coding Coding477[]; - static Coding Coding478[]; - static Coding Coding479[]; - static Coding Coding480[]; - static Coding Coding481[]; - static Coding Coding482[]; - static Coding Coding483[]; - static Coding Coding484[]; - static Coding Coding485[]; - static Coding Coding486[]; - static Coding Coding487[]; - static Coding Coding488[]; - static Coding Coding489[]; - static Coding Coding490[]; - static Coding Coding491[]; - static Coding Coding492[]; - static Coding Coding493[]; - static Coding Coding494[]; - static Coding Coding495[]; - static Coding Coding496[]; - static Coding Coding497[]; - static Coding Coding498[]; - static Coding Coding499[]; - static Coding Coding500[]; - static Coding Coding501[]; - static Coding Coding502[]; - static Coding Coding503[]; - static Coding Coding504[]; - static Coding Coding505[]; - static Coding Coding506[]; - static Coding Coding507[]; - static Coding Coding508[]; - static Coding Coding509[]; - static Coding Coding510[]; - static Coding Coding511[]; - static Coding Coding512[]; - static Coding Coding513[]; - static Coding Coding514[]; - static Coding Coding515[]; - static Coding Coding516[]; - static Coding Coding517[]; - static Coding Coding518[]; - static Coding Coding519[]; - static Coding Coding520[]; - static Coding Coding521[]; - static Coding Coding522[]; - static Coding Coding523[]; - static Coding Coding524[]; - static Coding Coding525[]; - static Coding Coding526[]; - static Coding Coding527[]; - static Coding Coding528[]; - static Coding Coding529[]; - static Coding Coding530[]; - static Coding Coding531[]; - static Coding Coding532[]; - static Coding Coding533[]; - static Coding Coding534[]; - static Coding Coding535[]; - static Coding Coding536[]; - static Coding Coding537[]; - static Coding Coding538[]; - static Coding Coding539[]; - static Coding Coding540[]; - static Coding Coding541[]; - static Coding Coding542[]; - static Coding Coding543[]; - static Coding Coding544[]; - static Coding Coding545[]; - static Coding Coding546[]; - static Coding Coding547[]; - static Coding Coding548[]; - static Coding Coding549[]; - static Coding Coding550[]; - static Coding Coding551[]; - static Coding Coding552[]; - static Coding Coding553[]; - static Coding Coding554[]; - static Coding Coding555[]; - static Coding Coding556[]; - static Coding Coding557[]; - static Coding Coding558[]; - static Coding Coding559[]; - static Coding Coding560[]; - static Coding Coding561[]; - static Coding Coding562[]; - static Coding Coding563[]; - static Coding Coding564[]; - static Coding Coding565[]; - static Coding Coding566[]; - static Coding Coding567[]; - static Coding Coding568[]; - static Coding Coding569[]; - static Coding Coding570[]; - static Coding Coding571[]; - static Coding Coding572[]; - static Coding Coding573[]; - static Coding Coding574[]; - static Coding Coding575[]; - static Coding Coding576[]; - static Coding Coding577[]; - static Coding Coding578[]; - static Coding Coding579[]; - static Coding Coding580[]; - static Coding Coding581[]; - static Coding Coding582[]; - static Coding Coding583[]; - static Coding Coding584[]; - static Coding Coding585[]; - static Coding Coding586[]; - static Coding Coding587[]; - static Coding Coding588[]; - static Coding Coding589[]; - static Coding Coding590[]; - static Coding Coding591[]; - static Coding Coding592[]; - static Coding Coding593[]; - static Coding Coding594[]; - static Coding Coding595[]; - static Coding Coding596[]; - static Coding Coding597[]; - static Coding Coding598[]; - static Coding Coding599[]; - static Coding Coding600[]; - static Coding Coding601[]; - static Coding Coding602[]; - static Coding Coding603[]; - static Coding Coding604[]; - static Coding Coding605[]; - static Coding Coding606[]; - static Coding Coding607[]; - static Coding Coding608[]; - static Coding Coding609[]; - static Coding Coding610[]; - static Coding Coding611[]; - static Coding Coding612[]; - static Coding Coding613[]; - static Coding Coding614[]; - static Coding Coding615[]; - static Coding Coding616[]; - static Coding Coding617[]; - static Coding Coding618[]; - static Coding Coding619[]; - static Coding Coding620[]; - static Coding Coding621[]; - static Coding Coding622[]; - static Coding Coding623[]; - static Coding Coding624[]; - static Coding Coding625[]; - static Coding Coding626[]; - static Coding Coding627[]; - static Coding Coding628[]; - static Coding Coding629[]; - static Coding Coding630[]; - static Coding Coding631[]; - static Coding Coding632[]; - static Coding Coding633[]; - static Coding Coding634[]; - static Coding Coding635[]; - static Coding Coding636[]; - static Coding Coding637[]; - static Coding Coding638[]; - static Coding Coding639[]; - static Coding Coding640[]; - static Coding Coding641[]; - static Coding Coding642[]; - static Coding Coding643[]; - static Coding Coding644[]; - static Coding Coding645[]; - static Coding Coding646[]; - static Coding Coding647[]; - static Coding Coding648[]; - static Coding Coding649[]; - static Coding Coding650[]; - static Coding Coding651[]; - static Coding Coding652[]; - static Coding Coding653[]; - static Coding Coding654[]; - static Coding Coding655[]; - static Coding Coding656[]; - static Coding Coding657[]; - static Coding Coding658[]; - static Coding Coding659[]; - static Coding Coding660[]; - static Coding Coding661[]; - static Coding Coding662[]; - static Coding Coding663[]; - static Coding Coding664[]; - static Coding Coding665[]; - static Coding Coding666[]; - static Coding Coding667[]; - static Coding Coding668[]; - static Coding Coding669[]; - static Coding Coding670[]; - static Coding Coding671[]; - static Coding Coding672[]; - static Coding Coding673[]; - static Coding Coding674[]; - static Coding Coding675[]; - static Coding Coding676[]; - static Coding Coding677[]; - static Coding Coding678[]; - static Coding Coding679[]; - static Coding Coding680[]; - static Coding Coding681[]; - static Coding Coding682[]; - static Coding Coding683[]; - static Coding Coding684[]; - static Coding Coding685[]; - static Coding Coding686[]; - static Coding Coding687[]; - static Coding Coding688[]; - static Coding Coding689[]; - static Coding Coding690[]; - static Coding Coding691[]; - static Coding Coding692[]; - static Coding Coding693[]; - static Coding Coding694[]; - static Coding Coding695[]; - static Coding Coding696[]; - static Coding Coding697[]; - static Coding Coding698[]; - static Coding Coding699[]; - static Coding Coding700[]; - static Coding Coding701[]; - static Coding Coding702[]; - static Coding Coding703[]; - static Coding Coding704[]; - static Coding Coding705[]; - static Coding Coding706[]; - static Coding Coding707[]; - static Coding Coding708[]; - static Coding Coding709[]; - static Coding Coding710[]; - static Coding Coding711[]; - static Coding Coding712[]; - static Coding Coding713[]; - static Coding Coding714[]; - static Coding Coding715[]; - static Coding Coding716[]; - static Coding Coding717[]; - static Coding Coding718[]; - static Coding Coding719[]; - static Coding Coding720[]; - static Coding Coding721[]; - static Coding Coding722[]; - static Coding Coding723[]; - static Coding Coding724[]; - static Coding Coding725[]; - static Coding Coding726[]; - static Coding Coding727[]; - static Coding Coding728[]; - static Coding Coding729[]; - static Coding Coding730[]; - static Coding Coding731[]; - static Coding Coding732[]; - static Coding* Codings[]; + static Coding Coding1[]; + static Coding Coding2[]; + static Coding Coding3[]; + static Coding Coding4[]; + static Coding Coding5[]; + static Coding Coding6[]; + static Coding Coding7[]; + static Coding Coding8[]; + static Coding Coding9[]; + static Coding Coding10[]; + static Coding Coding11[]; + static Coding Coding12[]; + static Coding Coding13[]; + static Coding Coding14[]; + static Coding Coding15[]; + static Coding Coding16[]; + static Coding Coding17[]; + static Coding Coding18[]; + static Coding Coding19[]; + static Coding Coding20[]; + static Coding Coding21[]; + static Coding Coding22[]; + static Coding Coding23[]; + static Coding Coding24[]; + static Coding Coding25[]; + static Coding Coding26[]; + static Coding Coding27[]; + static Coding Coding28[]; + static Coding Coding29[]; + static Coding Coding30[]; + static Coding Coding31[]; + static Coding Coding32[]; + static Coding Coding33[]; + static Coding Coding34[]; + static Coding Coding35[]; + static Coding Coding36[]; + static Coding Coding37[]; + static Coding Coding38[]; + static Coding Coding39[]; + static Coding Coding40[]; + static Coding Coding41[]; + static Coding Coding42[]; + static Coding Coding43[]; + static Coding Coding44[]; + static Coding Coding45[]; + static Coding Coding46[]; + static Coding Coding47[]; + static Coding Coding48[]; + static Coding Coding49[]; + static Coding Coding50[]; + static Coding Coding51[]; + static Coding Coding52[]; + static Coding Coding53[]; + static Coding Coding54[]; + static Coding Coding55[]; + static Coding Coding56[]; + static Coding Coding57[]; + static Coding Coding58[]; + static Coding Coding59[]; + static Coding Coding60[]; + static Coding Coding61[]; + static Coding Coding62[]; + static Coding Coding63[]; + static Coding Coding64[]; + static Coding Coding65[]; + static Coding Coding66[]; + static Coding Coding67[]; + static Coding Coding68[]; + static Coding Coding69[]; + static Coding Coding70[]; + static Coding Coding71[]; + static Coding Coding72[]; + static Coding Coding73[]; + static Coding Coding74[]; + static Coding Coding75[]; + static Coding Coding76[]; + static Coding Coding77[]; + static Coding Coding78[]; + static Coding Coding79[]; + static Coding Coding80[]; + static Coding Coding81[]; + static Coding Coding82[]; + static Coding Coding83[]; + static Coding Coding84[]; + static Coding Coding85[]; + static Coding Coding86[]; + static Coding Coding87[]; + static Coding Coding88[]; + static Coding Coding89[]; + static Coding Coding90[]; + static Coding Coding91[]; + static Coding Coding92[]; + static Coding Coding93[]; + static Coding Coding94[]; + static Coding Coding95[]; + static Coding Coding96[]; + static Coding Coding97[]; + static Coding Coding98[]; + static Coding Coding99[]; + static Coding Coding100[]; + static Coding Coding101[]; + static Coding Coding102[]; + static Coding Coding103[]; + static Coding Coding104[]; + static Coding Coding105[]; + static Coding Coding106[]; + static Coding Coding107[]; + static Coding Coding108[]; + static Coding Coding109[]; + static Coding Coding110[]; + static Coding Coding111[]; + static Coding Coding112[]; + static Coding Coding113[]; + static Coding Coding114[]; + static Coding Coding115[]; + static Coding Coding116[]; + static Coding Coding117[]; + static Coding Coding118[]; + static Coding Coding119[]; + static Coding Coding120[]; + static Coding Coding121[]; + static Coding Coding122[]; + static Coding Coding123[]; + static Coding Coding124[]; + static Coding Coding125[]; + static Coding Coding126[]; + static Coding Coding127[]; + static Coding Coding128[]; + static Coding Coding129[]; + static Coding Coding130[]; + static Coding Coding131[]; + static Coding Coding132[]; + static Coding Coding133[]; + static Coding Coding134[]; + static Coding Coding135[]; + static Coding Coding136[]; + static Coding Coding137[]; + static Coding Coding138[]; + static Coding Coding139[]; + static Coding Coding140[]; + static Coding Coding141[]; + static Coding Coding142[]; + static Coding Coding143[]; + static Coding Coding144[]; + static Coding Coding145[]; + static Coding Coding146[]; + static Coding Coding147[]; + static Coding Coding148[]; + static Coding Coding149[]; + static Coding Coding150[]; + static Coding Coding151[]; + static Coding Coding152[]; + static Coding Coding153[]; + static Coding Coding154[]; + static Coding Coding155[]; + static Coding Coding156[]; + static Coding Coding157[]; + static Coding Coding158[]; + static Coding Coding159[]; + static Coding Coding160[]; + static Coding Coding161[]; + static Coding Coding162[]; + static Coding Coding163[]; + static Coding Coding164[]; + static Coding Coding165[]; + static Coding Coding166[]; + static Coding Coding167[]; + static Coding Coding168[]; + static Coding Coding169[]; + static Coding Coding170[]; + static Coding Coding171[]; + static Coding Coding172[]; + static Coding Coding173[]; + static Coding Coding174[]; + static Coding Coding175[]; + static Coding Coding176[]; + static Coding Coding177[]; + static Coding Coding178[]; + static Coding Coding179[]; + static Coding Coding180[]; + static Coding Coding181[]; + static Coding Coding182[]; + static Coding Coding183[]; + static Coding Coding184[]; + static Coding Coding185[]; + static Coding Coding186[]; + static Coding Coding187[]; + static Coding Coding188[]; + static Coding Coding189[]; + static Coding Coding190[]; + static Coding Coding191[]; + static Coding Coding192[]; + static Coding Coding193[]; + static Coding Coding194[]; + static Coding Coding195[]; + static Coding Coding196[]; + static Coding Coding197[]; + static Coding Coding198[]; + static Coding Coding199[]; + static Coding Coding200[]; + static Coding Coding201[]; + static Coding Coding202[]; + static Coding Coding203[]; + static Coding Coding204[]; + static Coding Coding205[]; + static Coding Coding206[]; + static Coding Coding207[]; + static Coding Coding208[]; + static Coding Coding209[]; + static Coding Coding210[]; + static Coding Coding211[]; + static Coding Coding212[]; + static Coding Coding213[]; + static Coding Coding214[]; + static Coding Coding215[]; + static Coding Coding216[]; + static Coding Coding217[]; + static Coding Coding218[]; + static Coding Coding219[]; + static Coding Coding220[]; + static Coding Coding221[]; + static Coding Coding222[]; + static Coding Coding223[]; + static Coding Coding224[]; + static Coding Coding225[]; + static Coding Coding226[]; + static Coding Coding227[]; + static Coding Coding228[]; + static Coding Coding229[]; + static Coding Coding230[]; + static Coding Coding231[]; + static Coding Coding232[]; + static Coding Coding233[]; + static Coding Coding234[]; + static Coding Coding235[]; + static Coding Coding236[]; + static Coding Coding237[]; + static Coding Coding238[]; + static Coding Coding239[]; + static Coding Coding240[]; + static Coding Coding241[]; + static Coding Coding242[]; + static Coding Coding243[]; + static Coding Coding244[]; + static Coding Coding245[]; + static Coding Coding246[]; + static Coding Coding247[]; + static Coding Coding248[]; + static Coding Coding249[]; + static Coding Coding250[]; + static Coding Coding251[]; + static Coding Coding252[]; + static Coding Coding253[]; + static Coding Coding254[]; + static Coding Coding255[]; + static Coding Coding256[]; + static Coding Coding257[]; + static Coding Coding258[]; + static Coding Coding259[]; + static Coding Coding260[]; + static Coding Coding261[]; + static Coding Coding262[]; + static Coding Coding263[]; + static Coding Coding264[]; + static Coding Coding265[]; + static Coding Coding266[]; + static Coding Coding267[]; + static Coding Coding268[]; + static Coding Coding269[]; + static Coding Coding270[]; + static Coding Coding271[]; + static Coding Coding272[]; + static Coding Coding273[]; + static Coding Coding274[]; + static Coding Coding275[]; + static Coding Coding276[]; + static Coding Coding277[]; + static Coding Coding278[]; + static Coding Coding279[]; + static Coding Coding280[]; + static Coding Coding281[]; + static Coding Coding282[]; + static Coding Coding283[]; + static Coding Coding284[]; + static Coding Coding285[]; + static Coding Coding286[]; + static Coding Coding287[]; + static Coding Coding288[]; + static Coding Coding289[]; + static Coding Coding290[]; + static Coding Coding291[]; + static Coding Coding292[]; + static Coding Coding293[]; + static Coding Coding294[]; + static Coding Coding295[]; + static Coding Coding296[]; + static Coding Coding297[]; + static Coding Coding298[]; + static Coding Coding299[]; + static Coding Coding300[]; + static Coding Coding301[]; + static Coding Coding302[]; + static Coding Coding303[]; + static Coding Coding304[]; + static Coding Coding305[]; + static Coding Coding306[]; + static Coding Coding307[]; + static Coding Coding308[]; + static Coding Coding309[]; + static Coding Coding310[]; + static Coding Coding311[]; + static Coding Coding312[]; + static Coding Coding313[]; + static Coding Coding314[]; + static Coding Coding315[]; + static Coding Coding316[]; + static Coding Coding317[]; + static Coding Coding318[]; + static Coding Coding319[]; + static Coding Coding320[]; + static Coding Coding321[]; + static Coding Coding322[]; + static Coding Coding323[]; + static Coding Coding324[]; + static Coding Coding325[]; + static Coding Coding326[]; + static Coding Coding327[]; + static Coding Coding328[]; + static Coding Coding329[]; + static Coding Coding330[]; + static Coding Coding331[]; + static Coding Coding332[]; + static Coding Coding333[]; + static Coding Coding334[]; + static Coding Coding335[]; + static Coding Coding336[]; + static Coding Coding337[]; + static Coding Coding338[]; + static Coding Coding339[]; + static Coding Coding340[]; + static Coding Coding341[]; + static Coding Coding342[]; + static Coding Coding343[]; + static Coding Coding344[]; + static Coding Coding345[]; + static Coding Coding346[]; + static Coding Coding347[]; + static Coding Coding348[]; + static Coding Coding349[]; + static Coding Coding350[]; + static Coding Coding351[]; + static Coding Coding352[]; + static Coding Coding353[]; + static Coding Coding354[]; + static Coding Coding355[]; + static Coding Coding356[]; + static Coding Coding357[]; + static Coding Coding358[]; + static Coding Coding359[]; + static Coding Coding360[]; + static Coding Coding361[]; + static Coding Coding362[]; + static Coding Coding363[]; + static Coding Coding364[]; + static Coding Coding365[]; + static Coding Coding366[]; + static Coding Coding367[]; + static Coding Coding368[]; + static Coding Coding369[]; + static Coding Coding370[]; + static Coding Coding371[]; + static Coding Coding372[]; + static Coding Coding373[]; + static Coding Coding374[]; + static Coding Coding375[]; + static Coding Coding376[]; + static Coding Coding377[]; + static Coding Coding378[]; + static Coding Coding379[]; + static Coding Coding380[]; + static Coding Coding381[]; + static Coding Coding382[]; + static Coding Coding383[]; + static Coding Coding384[]; + static Coding Coding385[]; + static Coding Coding386[]; + static Coding Coding387[]; + static Coding Coding388[]; + static Coding Coding389[]; + static Coding Coding390[]; + static Coding Coding391[]; + static Coding Coding392[]; + static Coding Coding393[]; + static Coding Coding394[]; + static Coding Coding395[]; + static Coding Coding396[]; + static Coding Coding397[]; + static Coding Coding398[]; + static Coding Coding399[]; + static Coding Coding400[]; + static Coding Coding401[]; + static Coding Coding402[]; + static Coding Coding403[]; + static Coding Coding404[]; + static Coding Coding405[]; + static Coding Coding406[]; + static Coding Coding407[]; + static Coding Coding408[]; + static Coding Coding409[]; + static Coding Coding410[]; + static Coding Coding411[]; + static Coding Coding412[]; + static Coding Coding413[]; + static Coding Coding414[]; + static Coding Coding415[]; + static Coding Coding416[]; + static Coding Coding417[]; + static Coding Coding418[]; + static Coding Coding419[]; + static Coding Coding420[]; + static Coding Coding421[]; + static Coding Coding422[]; + static Coding Coding423[]; + static Coding Coding424[]; + static Coding Coding425[]; + static Coding Coding426[]; + static Coding Coding427[]; + static Coding Coding428[]; + static Coding Coding429[]; + static Coding Coding430[]; + static Coding Coding431[]; + static Coding Coding432[]; + static Coding Coding433[]; + static Coding Coding434[]; + static Coding Coding435[]; + static Coding Coding436[]; + static Coding Coding437[]; + static Coding Coding438[]; + static Coding Coding439[]; + static Coding Coding440[]; + static Coding Coding441[]; + static Coding Coding442[]; + static Coding Coding443[]; + static Coding Coding444[]; + static Coding Coding445[]; + static Coding Coding446[]; + static Coding Coding447[]; + static Coding Coding448[]; + static Coding Coding449[]; + static Coding Coding450[]; + static Coding Coding451[]; + static Coding Coding452[]; + static Coding Coding453[]; + static Coding Coding454[]; + static Coding Coding455[]; + static Coding Coding456[]; + static Coding Coding457[]; + static Coding Coding458[]; + static Coding Coding459[]; + static Coding Coding460[]; + static Coding Coding461[]; + static Coding Coding462[]; + static Coding Coding463[]; + static Coding Coding464[]; + static Coding Coding465[]; + static Coding Coding466[]; + static Coding Coding467[]; + static Coding Coding468[]; + static Coding Coding469[]; + static Coding Coding470[]; + static Coding Coding471[]; + static Coding Coding472[]; + static Coding Coding473[]; + static Coding Coding474[]; + static Coding Coding475[]; + static Coding Coding476[]; + static Coding Coding477[]; + static Coding Coding478[]; + static Coding Coding479[]; + static Coding Coding480[]; + static Coding Coding481[]; + static Coding Coding482[]; + static Coding Coding483[]; + static Coding Coding484[]; + static Coding Coding485[]; + static Coding Coding486[]; + static Coding Coding487[]; + static Coding Coding488[]; + static Coding Coding489[]; + static Coding Coding490[]; + static Coding Coding491[]; + static Coding Coding492[]; + static Coding Coding493[]; + static Coding Coding494[]; + static Coding Coding495[]; + static Coding Coding496[]; + static Coding Coding497[]; + static Coding Coding498[]; + static Coding Coding499[]; + static Coding Coding500[]; + static Coding Coding501[]; + static Coding Coding502[]; + static Coding Coding503[]; + static Coding Coding504[]; + static Coding Coding505[]; + static Coding Coding506[]; + static Coding Coding507[]; + static Coding Coding508[]; + static Coding Coding509[]; + static Coding Coding510[]; + static Coding Coding511[]; + static Coding Coding512[]; + static Coding Coding513[]; + static Coding Coding514[]; + static Coding Coding515[]; + static Coding Coding516[]; + static Coding Coding517[]; + static Coding Coding518[]; + static Coding Coding519[]; + static Coding Coding520[]; + static Coding Coding521[]; + static Coding Coding522[]; + static Coding Coding523[]; + static Coding Coding524[]; + static Coding Coding525[]; + static Coding Coding526[]; + static Coding Coding527[]; + static Coding Coding528[]; + static Coding Coding529[]; + static Coding Coding530[]; + static Coding Coding531[]; + static Coding Coding532[]; + static Coding Coding533[]; + static Coding Coding534[]; + static Coding Coding535[]; + static Coding Coding536[]; + static Coding Coding537[]; + static Coding Coding538[]; + static Coding Coding539[]; + static Coding Coding540[]; + static Coding Coding541[]; + static Coding Coding542[]; + static Coding Coding543[]; + static Coding Coding544[]; + static Coding Coding545[]; + static Coding Coding546[]; + static Coding Coding547[]; + static Coding Coding548[]; + static Coding Coding549[]; + static Coding Coding550[]; + static Coding Coding551[]; + static Coding Coding552[]; + static Coding Coding553[]; + static Coding Coding554[]; + static Coding Coding555[]; + static Coding Coding556[]; + static Coding Coding557[]; + static Coding Coding558[]; + static Coding Coding559[]; + static Coding Coding560[]; + static Coding Coding561[]; + static Coding Coding562[]; + static Coding Coding563[]; + static Coding Coding564[]; + static Coding Coding565[]; + static Coding Coding566[]; + static Coding Coding567[]; + static Coding Coding568[]; + static Coding Coding569[]; + static Coding Coding570[]; + static Coding Coding571[]; + static Coding Coding572[]; + static Coding Coding573[]; + static Coding Coding574[]; + static Coding Coding575[]; + static Coding Coding576[]; + static Coding Coding577[]; + static Coding Coding578[]; + static Coding Coding579[]; + static Coding Coding580[]; + static Coding Coding581[]; + static Coding Coding582[]; + static Coding Coding583[]; + static Coding Coding584[]; + static Coding Coding585[]; + static Coding Coding586[]; + static Coding Coding587[]; + static Coding Coding588[]; + static Coding Coding589[]; + static Coding Coding590[]; + static Coding Coding591[]; + static Coding Coding592[]; + static Coding Coding593[]; + static Coding Coding594[]; + static Coding Coding595[]; + static Coding Coding596[]; + static Coding Coding597[]; + static Coding Coding598[]; + static Coding Coding599[]; + static Coding Coding600[]; + static Coding Coding601[]; + static Coding Coding602[]; + static Coding Coding603[]; + static Coding Coding604[]; + static Coding Coding605[]; + static Coding Coding606[]; + static Coding Coding607[]; + static Coding Coding608[]; + static Coding Coding609[]; + static Coding Coding610[]; + static Coding Coding611[]; + static Coding Coding612[]; + static Coding Coding613[]; + static Coding Coding614[]; + static Coding Coding615[]; + static Coding Coding616[]; + static Coding Coding617[]; + static Coding Coding618[]; + static Coding Coding619[]; + static Coding Coding620[]; + static Coding Coding621[]; + static Coding Coding622[]; + static Coding Coding623[]; + static Coding Coding624[]; + static Coding Coding625[]; + static Coding Coding626[]; + static Coding Coding627[]; + static Coding Coding628[]; + static Coding Coding629[]; + static Coding Coding630[]; + static Coding Coding631[]; + static Coding Coding632[]; + static Coding Coding633[]; + static Coding Coding634[]; + static Coding Coding635[]; + static Coding Coding636[]; + static Coding Coding637[]; + static Coding Coding638[]; + static Coding Coding639[]; + static Coding Coding640[]; + static Coding Coding641[]; + static Coding Coding642[]; + static Coding Coding643[]; + static Coding Coding644[]; + static Coding Coding645[]; + static Coding Coding646[]; + static Coding Coding647[]; + static Coding Coding648[]; + static Coding Coding649[]; + static Coding Coding650[]; + static Coding Coding651[]; + static Coding Coding652[]; + static Coding Coding653[]; + static Coding Coding654[]; + static Coding Coding655[]; + static Coding Coding656[]; + static Coding Coding657[]; + static Coding Coding658[]; + static Coding Coding659[]; + static Coding Coding660[]; + static Coding Coding661[]; + static Coding Coding662[]; + static Coding Coding663[]; + static Coding Coding664[]; + static Coding Coding665[]; + static Coding Coding666[]; + static Coding Coding667[]; + static Coding Coding668[]; + static Coding Coding669[]; + static Coding Coding670[]; + static Coding Coding671[]; + static Coding Coding672[]; + static Coding Coding673[]; + static Coding Coding674[]; + static Coding Coding675[]; + static Coding Coding676[]; + static Coding Coding677[]; + static Coding Coding678[]; + static Coding Coding679[]; + static Coding Coding680[]; + static Coding Coding681[]; + static Coding Coding682[]; + static Coding Coding683[]; + static Coding Coding684[]; + static Coding Coding685[]; + static Coding Coding686[]; + static Coding Coding687[]; + static Coding Coding688[]; + static Coding Coding689[]; + static Coding Coding690[]; + static Coding Coding691[]; + static Coding Coding692[]; + static Coding Coding693[]; + static Coding Coding694[]; + static Coding Coding695[]; + static Coding Coding696[]; + static Coding Coding697[]; + static Coding Coding698[]; + static Coding Coding699[]; + static Coding Coding700[]; + static Coding Coding701[]; + static Coding Coding702[]; + static Coding Coding703[]; + static Coding Coding704[]; + static Coding Coding705[]; + static Coding Coding706[]; + static Coding Coding707[]; + static Coding Coding708[]; + static Coding Coding709[]; + static Coding Coding710[]; + static Coding Coding711[]; + static Coding Coding712[]; + static Coding Coding713[]; + static Coding Coding714[]; + static Coding Coding715[]; + static Coding Coding716[]; + static Coding Coding717[]; + static Coding Coding718[]; + static Coding Coding719[]; + static Coding Coding720[]; + static Coding Coding721[]; + static Coding Coding722[]; + static Coding Coding723[]; + static Coding Coding724[]; + static Coding Coding725[]; + static Coding Coding726[]; + static Coding Coding727[]; + static Coding Coding728[]; + static Coding Coding729[]; + static Coding Coding730[]; + static Coding Coding731[]; + static Coding Coding732[]; + static Coding *Codings[]; - static Coding prefixCoding1[]; - static Coding prefixCoding2[]; - static Coding prefixCoding3[]; - static Coding prefixCoding4[]; - static Coding prefixCoding5[]; - static Coding prefixCoding6[]; - static Coding prefixCoding7[]; - static Coding prefixCoding8[]; - static Coding prefixCoding9[]; - static Coding prefixCoding10[]; - static Coding* prefixCodings[]; -}; + static Coding prefixCoding1[]; + static Coding prefixCoding2[]; + static Coding prefixCoding3[]; + static Coding prefixCoding4[]; + static Coding prefixCoding5[]; + static Coding prefixCoding6[]; + static Coding prefixCoding7[]; + static Coding prefixCoding8[]; + static Coding prefixCoding9[]; + static Coding prefixCoding10[]; + static Coding *prefixCodings[]; + +}; #endif diff --git a/src/occ/x64Parser.cpp b/src/occ/x64Parser.cpp index e12352d5f..457accef1 100644 --- a/src/occ/x64Parser.cpp +++ b/src/occ/x64Parser.cpp @@ -5,59820 +5,58095 @@ #include "x64Operand.h" #include "x64Parser.h" -Coding x64Parser::stateCoding_eot[] = {{Coding::eot}}; +Coding x64Parser::stateCoding_eot[] = { { Coding::eot } }; Coding x64Parser::stateCoding1_1[] = { - {CODING_NAME("addr16")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addr16") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding1_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding2_1[] = { - {CODING_NAME("addr32")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addr32") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 103, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding2_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding3_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding4_1[] = { - {CODING_NAME("data16")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("data16") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding4_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding5_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding5_2[] = { - {CODING_NAME("data32")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("data32") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding6_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding7_1[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding7_2[] = { - {CODING_NAME("no64") Coding::illegal}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("no64") Coding::illegal }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding8_1[] = { - {CODING_NAME("only64") Coding::illegal}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("only64") Coding::illegal }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding8_2[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::stateCoding9_1[] = { - {CODING_NAME("rex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::StateFunc1() -{ - if (stateVars[0] != 16) - { - return stateCoding1_1; - } - if (stateVars[0] == 16) - { - return stateCoding1_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc2() -{ - if (stateVars[0] != 32) - { - return stateCoding2_1; - } - if (stateVars[0] == 32) - { - return stateCoding2_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc3() -{ - if (true) - { - return stateCoding3_1; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc4() -{ - if (stateVars[0] != 16) - { - return stateCoding4_1; - } - if (stateVars[0] == 16) - { - return stateCoding4_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc5() -{ - if (stateVars[0] != 16) - { - return stateCoding5_1; - } - if (stateVars[0] == 16) - { - return stateCoding5_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc6() -{ - if (true) - { - return stateCoding6_1; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc7() -{ - if (stateVars[0] != 64) - { - return stateCoding7_1; - } - if (stateVars[0] == 64) - { - return stateCoding7_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc8() -{ - if (stateVars[0] != 64) - { - return stateCoding8_1; - } - if (stateVars[0] == 64) - { - return stateCoding8_2; - } - return stateCoding_eot; -} -Coding* x64Parser::StateFunc9() -{ - if (true) - { - return stateCoding9_1; - } - return stateCoding_eot; + { CODING_NAME("rex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding *x64Parser::StateFunc1() +{ + if (stateVars[0]!=16) + { + return stateCoding1_1; + } + if (stateVars[0]==16) + { + return stateCoding1_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc2() +{ + if (stateVars[0]!=32) + { + return stateCoding2_1; + } + if (stateVars[0]==32) + { + return stateCoding2_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc3() +{ + if (true) + { + return stateCoding3_1; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc4() +{ + if (stateVars[0]!=16) + { + return stateCoding4_1; + } + if (stateVars[0]==16) + { + return stateCoding4_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc5() +{ + if (stateVars[0]!=16) + { + return stateCoding5_1; + } + if (stateVars[0]==16) + { + return stateCoding5_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc6() +{ + if (true) + { + return stateCoding6_1; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc7() +{ + if (stateVars[0]!=64) + { + return stateCoding7_1; + } + if (stateVars[0]==64) + { + return stateCoding7_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc8() +{ + if (stateVars[0]!=64) + { + return stateCoding8_1; + } + if (stateVars[0]==64) + { + return stateCoding8_2; + } + return stateCoding_eot; +} +Coding *x64Parser::StateFunc9() +{ + if (true) + { + return stateCoding9_1; + } + return stateCoding_eot; } x64Parser::StateFuncDispatchType x64Parser::stateFuncs[] = { - nullptr, - &x64Parser::StateFunc1, - &x64Parser::StateFunc2, - &x64Parser::StateFunc3, - &x64Parser::StateFunc4, - &x64Parser::StateFunc5, - &x64Parser::StateFunc6, - &x64Parser::StateFunc7, - &x64Parser::StateFunc8, - &x64Parser::StateFunc9, + nullptr, + &x64Parser::StateFunc1, + &x64Parser::StateFunc2, + &x64Parser::StateFunc3, + &x64Parser::StateFunc4, + &x64Parser::StateFunc5, + &x64Parser::StateFunc6, + &x64Parser::StateFunc7, + &x64Parser::StateFunc8, + &x64Parser::StateFunc9, }; bool x64Parser::Number1(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 1, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 1, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number2(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 1, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 1, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number3(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 6, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 6, 1, tokenPos); + } + return rv; } bool x64Parser::Number4(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 8, 1, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 8, 1, tokenPos); + } + return rv; } bool x64Parser::Number5(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number6(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number7(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(0, 0, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(0, 0, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number8(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 32) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==32) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number9(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 64) - { - rv = ParseNumber(0, 0, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==64) + { + rv = ParseNumber(0, 0, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number10(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(1, 1, 8, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(1, 1, 8, 0, tokenPos); + } + return rv; } bool x64Parser::Number11(int tokenPos) { - bool rv = false; - if (!rv) - { - rv = ParseNumber(-1, 1, 8, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv) + { + rv = ParseNumber(-1, 1, 8, 0, tokenPos); + } + return rv; } bool x64Parser::Number12(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number13(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(-2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(-2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number14(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number15(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] == 16) - { - rv = ParseNumber(-2, 1, 16, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]==16) + { + rv = ParseNumber(-2, 1, 16, 0, tokenPos); + } + return rv; } bool x64Parser::Number16(int tokenPos) { - bool rv = false; - if (!rv && stateVars[0] != 16) - { - rv = ParseNumber(4, 1, 32, 0, tokenPos); - } - return rv; + bool rv = false; + if (!rv && stateVars[0]!=16) + { + rv = ParseNumber(4, 1, 32, 0, tokenPos); + } + return rv; } bool x64Parser::Number17(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 1, 0); - if (!rv) - rv = SetNumber(tokenPos, 2, 1); - if (!rv) - rv = SetNumber(tokenPos, 4, 2); - if (!rv) - rv = SetNumber(tokenPos, 8, 3); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 1, 0); + if (!rv) + rv = SetNumber(tokenPos, 2, 1); + if (!rv) + rv = SetNumber(tokenPos, 4, 2); + if (!rv) + rv = SetNumber(tokenPos, 8, 3); + return rv; } bool x64Parser::Number18(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 0, 0); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 0, 0); + return rv; } bool x64Parser::Number19(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 1, 1); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 1, 1); + return rv; } bool x64Parser::Number20(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 2, 2); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 2, 2); + return rv; } bool x64Parser::Number21(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 4, 4); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 4, 4); + return rv; } bool x64Parser::Number22(int tokenPos) { - bool rv = false; - if (!rv) - rv = SetNumber(tokenPos, 8, 8); - return rv; + bool rv = false; + if (!rv) + rv = SetNumber(tokenPos, 8, 8); + return rv; } x64Parser::NumberDispatchType x64Parser::numberFuncs[] = { - &x64Parser::Number1, &x64Parser::Number2, &x64Parser::Number3, &x64Parser::Number4, &x64Parser::Number5, - &x64Parser::Number6, &x64Parser::Number7, &x64Parser::Number8, &x64Parser::Number9, &x64Parser::Number10, - &x64Parser::Number11, &x64Parser::Number12, &x64Parser::Number13, &x64Parser::Number14, &x64Parser::Number15, - &x64Parser::Number16, &x64Parser::Number17, &x64Parser::Number18, &x64Parser::Number19, &x64Parser::Number20, - &x64Parser::Number21, &x64Parser::Number22, + &x64Parser::Number1, + &x64Parser::Number2, + &x64Parser::Number3, + &x64Parser::Number4, + &x64Parser::Number5, + &x64Parser::Number6, + &x64Parser::Number7, + &x64Parser::Number8, + &x64Parser::Number9, + &x64Parser::Number10, + &x64Parser::Number11, + &x64Parser::Number12, + &x64Parser::Number13, + &x64Parser::Number14, + &x64Parser::Number15, + &x64Parser::Number16, + &x64Parser::Number17, + &x64Parser::Number18, + &x64Parser::Number19, + &x64Parser::Number20, + &x64Parser::Number21, + &x64Parser::Number22, }; -unsigned char x64Parser::RegClassData1[] = { - 255, - 15, - 0, - 0, -}; -unsigned char x64Parser::RegClassData2[] = { - 127, - 0, - 0, - 0, -}; -unsigned char x64Parser::RegClassData3[] = { - 190, - 15, - 0, - 0, -}; -unsigned char x64Parser::RegClassData4[] = { - 63, - 7, - 0, - 0, -}; -unsigned char x64Parser::RegClassData5[] = { - 191, - 12, - 0, - 0, -}; -unsigned char x64Parser::RegClassData6[] = { - 4, - 16, - 0, - 0, -}; -unsigned char x64Parser::RegClassData7[] = { - 8, - 96, - 0, - 0, -}; -unsigned char x64Parser::RegClassData8[] = { - 8, - 224, - 0, - 0, -}; -unsigned char x64Parser::RegClassData9[] = { - 16, - 0, - 3, - 0, -}; -unsigned char x64Parser::RegClassData10[] = { - 32, - 0, - 12, - 0, -}; -unsigned char x64Parser::RegClassData11[] = { - 128, - 0, - 48, - 0, -}; -unsigned char x64Parser::RegClassData12[] = { - 0, - 1, - 192, - 1, -}; -unsigned char x64Parser::RegClassData13[] = { - 0, - 2, - 0, - 14, -}; +unsigned char x64Parser::RegClassData1[] = {255, 15, 0, 0, }; +unsigned char x64Parser::RegClassData2[] = {127, 0, 0, 0, }; +unsigned char x64Parser::RegClassData3[] = {190, 15, 0, 0, }; +unsigned char x64Parser::RegClassData4[] = {63, 7, 0, 0, }; +unsigned char x64Parser::RegClassData5[] = {191, 12, 0, 0, }; +unsigned char x64Parser::RegClassData6[] = {4, 16, 0, 0, }; +unsigned char x64Parser::RegClassData7[] = {8, 96, 0, 0, }; +unsigned char x64Parser::RegClassData8[] = {8, 224, 0, 0, }; +unsigned char x64Parser::RegClassData9[] = {16, 0, 3, 0, }; +unsigned char x64Parser::RegClassData10[] = {32, 0, 12, 0, }; +unsigned char x64Parser::RegClassData11[] = {128, 0, 48, 0, }; +unsigned char x64Parser::RegClassData12[] = {0, 1, 192, 1, }; +unsigned char x64Parser::RegClassData13[] = {0, 2, 0, 14, }; -unsigned char x64Parser::registerData17[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData13[] = { - 0, 0, 0, 32, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData6[] = { - 136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData9[] = { - 16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData22[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, -}; -unsigned char x64Parser::registerData23[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, -}; -unsigned char x64Parser::registerData21[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, 0, -}; -unsigned char x64Parser::registerData1[] = { - 255, 255, 255, 255, 15, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData4[] = { - 2, 4, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData16[] = { - 0, 0, 0, 0, 0, 0, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData7[] = { - 136, 16, 33, 66, 4, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData10[] = { - 16, 33, 66, 132, 8, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData3[] = { - 33, 66, 132, 8, 17, 17, 17, 17, 1, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData12[] = { - 0, 0, 0, 120, 0, 0, 96, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData5[] = { - 68, 136, 16, 33, 34, 34, 34, 34, 2, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData8[] = { - 136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData11[] = { - 16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData2[] = { - 35, 70, 140, 24, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData15[] = { - 0, 0, 0, 0, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData19[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 32, 73, 146, 4, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData18[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 224, 255, 255, 31, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData20[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 7, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData14[] = { - 0, 0, 0, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -}; -unsigned char x64Parser::registerData24[] = { - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, -}; +unsigned char x64Parser::registerData17[] = {0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData13[] = {0, 0, 0, 32, 0, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData6[] = {136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData9[] = {16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData22[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, }; +unsigned char x64Parser::registerData23[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, }; +unsigned char x64Parser::registerData21[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, 0, 0, 0, }; +unsigned char x64Parser::registerData1[] = {255, 255, 255, 255, 15, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData4[] = {2, 4, 8, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData16[] = {0, 0, 0, 0, 0, 0, 32, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData7[] = {136, 16, 33, 66, 4, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData10[] = {16, 33, 66, 132, 8, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData3[] = {33, 66, 132, 8, 17, 17, 17, 17, 1, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData12[] = {0, 0, 0, 120, 0, 0, 96, 96, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData5[] = {68, 136, 16, 33, 34, 34, 34, 34, 2, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData8[] = {136, 16, 33, 66, 68, 68, 68, 68, 4, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData11[] = {16, 33, 66, 132, 136, 136, 136, 136, 8, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData2[] = {35, 70, 140, 24, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData15[] = {0, 0, 0, 0, 16, 16, 16, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData19[] = {0, 0, 0, 0, 0, 0, 0, 0, 32, 73, 146, 4, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData18[] = {0, 0, 0, 0, 0, 0, 0, 0, 224, 255, 255, 31, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData20[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 224, 7, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData14[] = {0, 0, 0, 0, 240, 255, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; +unsigned char x64Parser::registerData24[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 248, 7, }; -unsigned char* x64Parser::registerDataIndirect[] = { - registerData1, registerData2, registerData3, registerData4, registerData5, registerData6, registerData7, registerData8, - registerData9, registerData10, registerData11, registerData12, registerData13, registerData14, registerData15, registerData16, - registerData17, registerData18, registerData19, registerData20, registerData21, registerData22, registerData23, registerData24, +unsigned char *x64Parser::registerDataIndirect[] = { + registerData1, + registerData2, + registerData3, + registerData4, + registerData5, + registerData6, + registerData7, + registerData8, + registerData9, + registerData10, + registerData11, + registerData12, + registerData13, + registerData14, + registerData15, + registerData16, + registerData17, + registerData18, + registerData19, + registerData20, + registerData21, + registerData22, + registerData23, + registerData24, }; int x64Parser::registerValues[][8] = { - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - 0, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - 1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - 0, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - 1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 8, - 0, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 8, - 2, - -1, - -1, - -1, - }, - { - -1, - -1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 0, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 0, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 1, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 1, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 2, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 2, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 3, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 3, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 4, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 4, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 5, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 5, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 6, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 6, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 0, - 7, - 0, - 0, - 0, - -1, - -1, - -1, - }, - { - 1, - 7, - 4, - 0, - 2, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - 38, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - 46, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - 54, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - 62, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - 100, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - 101, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 0, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 1, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 2, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 3, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 4, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 5, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 6, - -1, - -1, - -1, - -1, - -1, - -1, - }, - { - -1, - 7, - -1, - -1, - -1, - -1, - -1, - -1, - }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 8, 0, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 1, 0, 4, 8, 2, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 8, 0, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 1, 1, 4, 8, 2, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 8, 0, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 1, 2, 4, 8, 2, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 0, 0, 0, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 8, 0, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 1, 3, 4, 8, 2, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 8, 0, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 1, 4, 4, 8, 2, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, 1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 8, 0, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 1, 5, 4, 8, 2, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, 0, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 8, 0, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 1, 6, 4, 8, 2, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, 1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 8, 0, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { 1, 7, 4, 8, 2, -1, -1, -1, }, + { -1, -1, -1, -1, -1, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 0, 0, 0, 0, 0, -1, -1, -1, }, + { 1, 0, 4, 0, 2, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 0, 1, 0, 0, 0, -1, -1, -1, }, + { 1, 1, 4, 0, 2, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 0, 2, 0, 0, 0, -1, -1, -1, }, + { 1, 2, 4, 0, 2, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 0, 3, 0, 0, 0, -1, -1, -1, }, + { 1, 3, 4, 0, 2, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 0, 4, 0, 0, 0, -1, -1, -1, }, + { 1, 4, 4, 0, 2, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 0, 5, 0, 0, 0, -1, -1, -1, }, + { 1, 5, 4, 0, 2, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 0, 6, 0, 0, 0, -1, -1, -1, }, + { 1, 6, 4, 0, 2, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 0, 7, 0, 0, 0, -1, -1, -1, }, + { 1, 7, 4, 0, 2, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, 38, }, + { -1, 1, -1, -1, -1, -1, -1, 46, }, + { -1, 2, -1, -1, -1, -1, -1, 54, }, + { -1, 3, -1, -1, -1, -1, -1, 62, }, + { -1, 4, -1, -1, -1, -1, -1, 100, }, + { -1, 5, -1, -1, -1, -1, -1, 101, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, + { -1, 0, -1, -1, -1, -1, -1, -1, }, + { -1, 1, -1, -1, -1, -1, -1, -1, }, + { -1, 2, -1, -1, -1, -1, -1, -1, }, + { -1, 3, -1, -1, -1, -1, -1, -1, }, + { -1, 4, -1, -1, -1, -1, -1, -1, }, + { -1, 5, -1, -1, -1, -1, -1, -1, }, + { -1, 6, -1, -1, -1, -1, -1, -1, }, + { -1, 7, -1, -1, -1, -1, -1, -1, }, }; void x64Parser::Init() { - bits.SetBigEndian(IsBigEndian()); - memset(&stateVars, 0, sizeof(stateVars)); - stateVars[0] = 16; - tokenTable[""] = 0; - tokenTable["*"] = 5; - tokenTable["+"] = 4; - tokenTable[","] = 7; - tokenTable[":"] = 3; - tokenTable["["] = 1; - tokenTable["]"] = 2; - tokenTable["byte"] = 11; - tokenTable["dword"] = 9; - tokenTable["far"] = 15; - tokenTable["near"] = 14; - tokenTable["qword"] = 10; - tokenTable["short"] = 13; - tokenTable["tword"] = 12; - tokenTable["word"] = 8; - tokenTable["al"] = 1000; - tokenTable["ah"] = 1001; - tokenTable["ax"] = 1002; - tokenTable["eax"] = 1003; - tokenTable["rax"] = 1004; - tokenTable["r8b"] = 1005; - tokenTable["r8w"] = 1006; - tokenTable["r8d"] = 1007; - tokenTable["r8"] = 1008; - tokenTable["cl"] = 1009; - tokenTable["ch"] = 1010; - tokenTable["cx"] = 1011; - tokenTable["ecx"] = 1012; - tokenTable["rcx"] = 1013; - tokenTable["r9b"] = 1014; - tokenTable["r9w"] = 1015; - tokenTable["r9d"] = 1016; - tokenTable["r9"] = 1017; - tokenTable["dl"] = 1018; - tokenTable["dh"] = 1019; - tokenTable["dx"] = 1020; - tokenTable["edx"] = 1021; - tokenTable["rdx"] = 1022; - tokenTable["r10b"] = 1023; - tokenTable["r10w"] = 1024; - tokenTable["r10d"] = 1025; - tokenTable["r10"] = 1026; - tokenTable["bl"] = 1027; - tokenTable["bh"] = 1028; - tokenTable["bx"] = 1029; - tokenTable["ebx"] = 1030; - tokenTable["rbx"] = 1031; - tokenTable["r11b"] = 1032; - tokenTable["r11w"] = 1033; - tokenTable["r11d"] = 1034; - tokenTable["r11"] = 1035; - tokenTable["spl"] = 1036; - tokenTable["sp"] = 1037; - tokenTable["esp"] = 1038; - tokenTable["rsp"] = 1039; - tokenTable["r12b"] = 1040; - tokenTable["r12w"] = 1041; - tokenTable["r12d"] = 1042; - tokenTable["r12"] = 1043; - tokenTable["bpl"] = 1044; - tokenTable["bp"] = 1045; - tokenTable["ebp"] = 1046; - tokenTable["rbp"] = 1047; - tokenTable["r13b"] = 1048; - tokenTable["r13w"] = 1049; - tokenTable["r13d"] = 1050; - tokenTable["r13"] = 1051; - tokenTable["sil"] = 1052; - tokenTable["si"] = 1053; - tokenTable["esi"] = 1054; - tokenTable["rsi"] = 1055; - tokenTable["r14b"] = 1056; - tokenTable["r14w"] = 1057; - tokenTable["r14d"] = 1058; - tokenTable["r14"] = 1059; - tokenTable["dil"] = 1060; - tokenTable["di"] = 1061; - tokenTable["edi"] = 1062; - tokenTable["rdi"] = 1063; - tokenTable["r15b"] = 1064; - tokenTable["r15w"] = 1065; - tokenTable["r15d"] = 1066; - tokenTable["r15"] = 1067; - tokenTable["rip"] = 1068; - tokenTable["mm0"] = 1069; - tokenTable["xmm0"] = 1070; - tokenTable["xmm8"] = 1071; - tokenTable["mm1"] = 1072; - tokenTable["xmm1"] = 1073; - tokenTable["xmm9"] = 1074; - tokenTable["mm2"] = 1075; - tokenTable["xmm2"] = 1076; - tokenTable["xmm10"] = 1077; - tokenTable["mm3"] = 1078; - tokenTable["xmm3"] = 1079; - tokenTable["xmm11"] = 1080; - tokenTable["mm4"] = 1081; - tokenTable["xmm4"] = 1082; - tokenTable["xmm12"] = 1083; - tokenTable["mm5"] = 1084; - tokenTable["xmm5"] = 1085; - tokenTable["xmm13"] = 1086; - tokenTable["mm6"] = 1087; - tokenTable["xmm6"] = 1088; - tokenTable["xmm14"] = 1089; - tokenTable["mm7"] = 1090; - tokenTable["xmm7"] = 1091; - tokenTable["xmm15"] = 1092; - tokenTable["es"] = 1093; - tokenTable["cs"] = 1094; - tokenTable["ss"] = 1095; - tokenTable["ds"] = 1096; - tokenTable["fs"] = 1097; - tokenTable["gs"] = 1098; - tokenTable["st0"] = 1099; - tokenTable["st1"] = 1100; - tokenTable["st2"] = 1101; - tokenTable["st3"] = 1102; - tokenTable["st4"] = 1103; - tokenTable["st5"] = 1104; - tokenTable["st6"] = 1105; - tokenTable["st7"] = 1106; - tokenTable["cr0"] = 1107; - tokenTable["cr1"] = 1108; - tokenTable["cr2"] = 1109; - tokenTable["cr3"] = 1110; - tokenTable["cr4"] = 1111; - tokenTable["cr5"] = 1112; - tokenTable["cr6"] = 1113; - tokenTable["cr7"] = 1114; - tokenTable["dr0"] = 1115; - tokenTable["dr1"] = 1116; - tokenTable["dr2"] = 1117; - tokenTable["dr3"] = 1118; - tokenTable["dr4"] = 1119; - tokenTable["dr5"] = 1120; - tokenTable["dr6"] = 1121; - tokenTable["dr7"] = 1122; - tokenTable["tr0"] = 1123; - tokenTable["tr1"] = 1124; - tokenTable["tr2"] = 1125; - tokenTable["tr3"] = 1126; - tokenTable["tr4"] = 1127; - tokenTable["tr5"] = 1128; - tokenTable["tr6"] = 1129; - tokenTable["tr7"] = 1130; - opcodeTable["aaa"] = 32; - opcodeTable["aad"] = 33; - opcodeTable["aam"] = 34; - opcodeTable["aas"] = 35; - opcodeTable["adc"] = 36; - opcodeTable["add"] = 37; - opcodeTable["and"] = 38; - opcodeTable["arpl"] = 39; - opcodeTable["bound"] = 40; - opcodeTable["bsf"] = 41; - opcodeTable["bsr"] = 42; - opcodeTable["bswap"] = 43; - opcodeTable["bt"] = 44; - opcodeTable["btc"] = 45; - opcodeTable["btr"] = 46; - opcodeTable["bts"] = 47; - opcodeTable["call"] = 48; - opcodeTable["cbw"] = 49; - opcodeTable["cdq"] = 50; - opcodeTable["cdqe"] = 51; - opcodeTable["clc"] = 52; - opcodeTable["cld"] = 53; - opcodeTable["cli"] = 54; - opcodeTable["clts"] = 55; - opcodeTable["cmc"] = 56; - opcodeTable["cmova"] = 57; - opcodeTable["cmovae"] = 58; - opcodeTable["cmovb"] = 59; - opcodeTable["cmovbe"] = 60; - opcodeTable["cmovc"] = 61; - opcodeTable["cmove"] = 62; - opcodeTable["cmovg"] = 63; - opcodeTable["cmovge"] = 64; - opcodeTable["cmovl"] = 65; - opcodeTable["cmovle"] = 66; - opcodeTable["cmovna"] = 67; - opcodeTable["cmovnae"] = 68; - opcodeTable["cmovnb"] = 69; - opcodeTable["cmovnbe"] = 70; - opcodeTable["cmovnc"] = 71; - opcodeTable["cmovne"] = 72; - opcodeTable["cmovng"] = 73; - opcodeTable["cmovnge"] = 74; - opcodeTable["cmovnl"] = 75; - opcodeTable["cmovnle"] = 76; - opcodeTable["cmovno"] = 77; - opcodeTable["cmovnp"] = 78; - opcodeTable["cmovns"] = 79; - opcodeTable["cmovnz"] = 80; - opcodeTable["cmovo"] = 81; - opcodeTable["cmovp"] = 82; - opcodeTable["cmovpe"] = 83; - opcodeTable["cmovpo"] = 84; - opcodeTable["cmovs"] = 85; - opcodeTable["cmovz"] = 86; - opcodeTable["cmp"] = 87; - opcodeTable["cmps"] = 88; - opcodeTable["cmpsb"] = 89; - opcodeTable["cmpsw"] = 90; - opcodeTable["cmpsd"] = 91; - opcodeTable["cmpsq"] = 92; - opcodeTable["cmpxchg"] = 93; - opcodeTable["cmpxchg8b"] = 94; - opcodeTable["cmpxchg16b"] = 95; - opcodeTable["cpuid"] = 96; - opcodeTable["cqo"] = 97; - opcodeTable["cwd"] = 98; - opcodeTable["cwde"] = 99; - opcodeTable["daa"] = 100; - opcodeTable["das"] = 101; - opcodeTable["dec"] = 102; - opcodeTable["div"] = 103; - opcodeTable["enter"] = 104; - opcodeTable["esc"] = 105; - opcodeTable["f2xm1"] = 106; - opcodeTable["fabs"] = 107; - opcodeTable["fadd"] = 108; - opcodeTable["faddp"] = 109; - opcodeTable["fbld"] = 110; - opcodeTable["fbstp"] = 111; - opcodeTable["fchs"] = 112; - opcodeTable["fclex"] = 113; - opcodeTable["fnclex"] = 114; - opcodeTable["fcmovb"] = 115; - opcodeTable["fcmovbe"] = 116; - opcodeTable["fcmove"] = 117; - opcodeTable["fcmovnb"] = 118; - opcodeTable["fcmovnbe"] = 119; - opcodeTable["fcmovne"] = 120; - opcodeTable["fcmovnu"] = 121; - opcodeTable["fcmovu"] = 122; - opcodeTable["fcom"] = 123; - opcodeTable["fcomi"] = 124; - opcodeTable["fcomip"] = 125; - opcodeTable["fcomp"] = 126; - opcodeTable["fcompp"] = 127; - opcodeTable["fcos"] = 128; - opcodeTable["fdecstp"] = 129; - opcodeTable["fdisi"] = 130; - opcodeTable["fdiv"] = 131; - opcodeTable["fdivp"] = 132; - opcodeTable["fdivr"] = 133; - opcodeTable["fdivrp"] = 134; - opcodeTable["feni"] = 135; - opcodeTable["ffree"] = 136; - opcodeTable["ffreep"] = 137; - opcodeTable["fiadd"] = 138; - opcodeTable["ficom"] = 139; - opcodeTable["ficomp"] = 140; - opcodeTable["fidiv"] = 141; - opcodeTable["fidivr"] = 142; - opcodeTable["fild"] = 143; - opcodeTable["fimul"] = 144; - opcodeTable["fincstp"] = 145; - opcodeTable["finit"] = 146; - opcodeTable["fninit"] = 147; - opcodeTable["fist"] = 148; - opcodeTable["fistp"] = 149; - opcodeTable["fisub"] = 150; - opcodeTable["fisubr"] = 151; - opcodeTable["fld"] = 152; - opcodeTable["fld1"] = 153; - opcodeTable["fldcw"] = 154; - opcodeTable["fldenv"] = 155; - opcodeTable["fldl2e"] = 156; - opcodeTable["fldl2t"] = 157; - opcodeTable["fldlg2"] = 158; - opcodeTable["fldln2"] = 159; - opcodeTable["fldpi"] = 160; - opcodeTable["fldz"] = 161; - opcodeTable["fmul"] = 162; - opcodeTable["fmulp"] = 163; - opcodeTable["fnop"] = 164; - opcodeTable["fnsave"] = 165; - opcodeTable["fpatan"] = 166; - opcodeTable["fprem"] = 167; - opcodeTable["fprem1"] = 168; - opcodeTable["fptan"] = 169; - opcodeTable["frndint"] = 170; - opcodeTable["frstor"] = 171; - opcodeTable["fsave"] = 172; - opcodeTable["fscale"] = 173; - opcodeTable["fsetpm"] = 174; - opcodeTable["fsin"] = 175; - opcodeTable["fsincos"] = 176; - opcodeTable["fsqrt"] = 177; - opcodeTable["fst"] = 178; - opcodeTable["fstcw"] = 179; - opcodeTable["fnstcw"] = 180; - opcodeTable["fstenv"] = 181; - opcodeTable["fnstenv"] = 182; - opcodeTable["fstp"] = 183; - opcodeTable["fstsw"] = 184; - opcodeTable["fnstsw"] = 185; - opcodeTable["fsub"] = 186; - opcodeTable["fsubp"] = 187; - opcodeTable["fsubr"] = 188; - opcodeTable["fsubrp"] = 189; - opcodeTable["ftst"] = 190; - opcodeTable["fucom"] = 191; - opcodeTable["fucomi"] = 192; - opcodeTable["fucomip"] = 193; - opcodeTable["fucomp"] = 194; - opcodeTable["fucompp"] = 195; - opcodeTable["fwait"] = 196; - opcodeTable["fxam"] = 197; - opcodeTable["fxch"] = 198; - opcodeTable["fxch4"] = 199; - opcodeTable["fxch7"] = 200; - opcodeTable["fxrstor"] = 201; - opcodeTable["fxsave"] = 202; - opcodeTable["fxtract"] = 203; - opcodeTable["fyl2x"] = 204; - opcodeTable["fyl2xp1"] = 205; - opcodeTable["hlt"] = 206; - opcodeTable["icebp"] = 207; - opcodeTable["idiv"] = 208; - opcodeTable["imul"] = 209; - opcodeTable["in"] = 210; - opcodeTable["ins"] = 211; - opcodeTable["insb"] = 212; - opcodeTable["insw"] = 213; - opcodeTable["insd"] = 214; - opcodeTable["inc"] = 215; - opcodeTable["int"] = 216; - opcodeTable["int1"] = 217; - opcodeTable["int3"] = 218; - opcodeTable["into"] = 219; - opcodeTable["invd"] = 220; - opcodeTable["invlpg"] = 221; - opcodeTable["iret"] = 222; - opcodeTable["iretw"] = 223; - opcodeTable["iretd"] = 224; - opcodeTable["iretq"] = 225; - opcodeTable["ja"] = 226; - opcodeTable["jae"] = 227; - opcodeTable["jb"] = 228; - opcodeTable["jbe"] = 229; - opcodeTable["jc"] = 230; - opcodeTable["jcxz"] = 231; - opcodeTable["jecxz"] = 232; - opcodeTable["je"] = 233; - opcodeTable["jg"] = 234; - opcodeTable["jge"] = 235; - opcodeTable["jl"] = 236; - opcodeTable["jle"] = 237; - opcodeTable["jmp"] = 238; - opcodeTable["jna"] = 239; - opcodeTable["jnae"] = 240; - opcodeTable["jnb"] = 241; - opcodeTable["jnbe"] = 242; - opcodeTable["jnc"] = 243; - opcodeTable["jne"] = 244; - opcodeTable["jng"] = 245; - opcodeTable["jnge"] = 246; - opcodeTable["jnl"] = 247; - opcodeTable["jnle"] = 248; - opcodeTable["jno"] = 249; - opcodeTable["jnp"] = 250; - opcodeTable["jns"] = 251; - opcodeTable["jnz"] = 252; - opcodeTable["jo"] = 253; - opcodeTable["jp"] = 254; - opcodeTable["jpe"] = 255; - opcodeTable["jpo"] = 256; - opcodeTable["js"] = 257; - opcodeTable["jz"] = 258; - opcodeTable["lahf"] = 259; - opcodeTable["lar"] = 260; - opcodeTable["lds"] = 261; - opcodeTable["lea"] = 262; - opcodeTable["leave"] = 263; - opcodeTable["les"] = 264; - opcodeTable["lfence"] = 265; - opcodeTable["lfs"] = 266; - opcodeTable["lgdt"] = 267; - opcodeTable["lgs"] = 268; - opcodeTable["lidt"] = 269; - opcodeTable["lldt"] = 270; - opcodeTable["lmsw"] = 271; - opcodeTable["lods"] = 272; - opcodeTable["lodsb"] = 273; - opcodeTable["lodsw"] = 274; - opcodeTable["lodsd"] = 275; - opcodeTable["lodsq"] = 276; - opcodeTable["loop"] = 277; - opcodeTable["loope"] = 278; - opcodeTable["loopne"] = 279; - opcodeTable["loopnz"] = 280; - opcodeTable["loopz"] = 281; - opcodeTable["lsl"] = 282; - opcodeTable["lss"] = 283; - opcodeTable["ltr"] = 284; - opcodeTable["mov"] = 285; - opcodeTable["movs"] = 286; - opcodeTable["movbe"] = 287; - opcodeTable["movsb"] = 288; - opcodeTable["movsw"] = 289; - opcodeTable["movsd"] = 290; - opcodeTable["movsq"] = 291; - opcodeTable["movsx"] = 292; - opcodeTable["movzx"] = 293; - opcodeTable["movsxd"] = 294; - opcodeTable["mul"] = 295; - opcodeTable["neg"] = 296; - opcodeTable["nop"] = 297; - opcodeTable["not"] = 298; - opcodeTable["or"] = 299; - opcodeTable["out"] = 300; - opcodeTable["outs"] = 301; - opcodeTable["outsb"] = 302; - opcodeTable["outsw"] = 303; - opcodeTable["outsd"] = 304; - opcodeTable["pop"] = 305; - opcodeTable["popa"] = 306; - opcodeTable["popaw"] = 307; - opcodeTable["popad"] = 308; - opcodeTable["popcnt"] = 309; - opcodeTable["popf"] = 310; - opcodeTable["popfw"] = 311; - opcodeTable["popfd"] = 312; - opcodeTable["popfq"] = 313; - opcodeTable["prefetchnta"] = 314; - opcodeTable["prefetcht0"] = 315; - opcodeTable["prefetcht1"] = 316; - opcodeTable["prefetcht2"] = 317; - opcodeTable["push"] = 318; - opcodeTable["pusha"] = 319; - opcodeTable["pushaw"] = 320; - opcodeTable["pushad"] = 321; - opcodeTable["pushf"] = 322; - opcodeTable["pushfw"] = 323; - opcodeTable["pushfd"] = 324; - opcodeTable["pushfq"] = 325; - opcodeTable["rcl"] = 326; - opcodeTable["rcr"] = 327; - opcodeTable["rdmsr"] = 328; - opcodeTable["rdpmc"] = 329; - opcodeTable["rdtsc"] = 330; - opcodeTable["ret"] = 331; - opcodeTable["retf"] = 332; - opcodeTable["rol"] = 333; - opcodeTable["ror"] = 334; - opcodeTable["rsm"] = 335; - opcodeTable["sahf"] = 336; - opcodeTable["sal"] = 337; - opcodeTable["sar"] = 338; - opcodeTable["sbb"] = 339; - opcodeTable["scas"] = 340; - opcodeTable["scasb"] = 341; - opcodeTable["scasw"] = 342; - opcodeTable["scasd"] = 343; - opcodeTable["scasq"] = 344; - opcodeTable["seta"] = 345; - opcodeTable["setae"] = 346; - opcodeTable["setb"] = 347; - opcodeTable["setbe"] = 348; - opcodeTable["setc"] = 349; - opcodeTable["sete"] = 350; - opcodeTable["setg"] = 351; - opcodeTable["setge"] = 352; - opcodeTable["setl"] = 353; - opcodeTable["setle"] = 354; - opcodeTable["setna"] = 355; - opcodeTable["setnae"] = 356; - opcodeTable["setnb"] = 357; - opcodeTable["setnbe"] = 358; - opcodeTable["setnc"] = 359; - opcodeTable["setne"] = 360; - opcodeTable["setng"] = 361; - opcodeTable["setnge"] = 362; - opcodeTable["setnl"] = 363; - opcodeTable["setnle"] = 364; - opcodeTable["setno"] = 365; - opcodeTable["setnp"] = 366; - opcodeTable["setns"] = 367; - opcodeTable["setnz"] = 368; - opcodeTable["seto"] = 369; - opcodeTable["setp"] = 370; - opcodeTable["setpe"] = 371; - opcodeTable["setpo"] = 372; - opcodeTable["sets"] = 373; - opcodeTable["setz"] = 374; - opcodeTable["sfence"] = 375; - opcodeTable["sgdt"] = 376; - opcodeTable["shl"] = 377; - opcodeTable["shld"] = 378; - opcodeTable["shr"] = 379; - opcodeTable["shrd"] = 380; - opcodeTable["sidt"] = 381; - opcodeTable["sldt"] = 382; - opcodeTable["smsw"] = 383; - opcodeTable["stc"] = 384; - opcodeTable["std"] = 385; - opcodeTable["sti"] = 386; - opcodeTable["stos"] = 387; - opcodeTable["stosb"] = 388; - opcodeTable["stosw"] = 389; - opcodeTable["stosd"] = 390; - opcodeTable["stosq"] = 391; - opcodeTable["str"] = 392; - opcodeTable["sub"] = 393; - opcodeTable["syscall"] = 394; - opcodeTable["sysenter"] = 395; - opcodeTable["sysexit"] = 396; - opcodeTable["sysret"] = 397; - opcodeTable["test"] = 398; - opcodeTable["ud2"] = 399; - opcodeTable["verr"] = 400; - opcodeTable["verw"] = 401; - opcodeTable["wait"] = 402; - opcodeTable["wbinvd"] = 403; - opcodeTable["wrmsr"] = 404; - opcodeTable["xadd"] = 405; - opcodeTable["xchg"] = 406; - opcodeTable["xlat"] = 407; - opcodeTable["xlatb"] = 408; - opcodeTable["xor"] = 409; - opcodeTable["xrstor"] = 410; - opcodeTable["xrstor64"] = 411; - opcodeTable["xsave"] = 412; - opcodeTable["xsave64"] = 413; - opcodeTable["xsetbv"] = 414; - opcodeTable["addpd"] = 415; - opcodeTable["addps"] = 416; - opcodeTable["addsd"] = 417; - opcodeTable["addss"] = 418; - opcodeTable["addsubpd"] = 419; - opcodeTable["addsubps"] = 420; - opcodeTable["andnpd"] = 421; - opcodeTable["andnps"] = 422; - opcodeTable["andpd"] = 423; - opcodeTable["andps"] = 424; - opcodeTable["blendpd"] = 425; - opcodeTable["blendps"] = 426; - opcodeTable["cmppd"] = 427; - opcodeTable["cmpps"] = 428; - opcodeTable["comisd"] = 429; - opcodeTable["comiss"] = 430; - opcodeTable["cvtdq2pd"] = 431; - opcodeTable["cvtdq2ps"] = 432; - opcodeTable["cvtpd2dq"] = 433; - opcodeTable["cvtpd2pi"] = 434; - opcodeTable["cvtpd2ps"] = 435; - opcodeTable["cvtpi2pd"] = 436; - opcodeTable["cvtpi2ps"] = 437; - opcodeTable["cvtps2dq"] = 438; - opcodeTable["cvtps2pd"] = 439; - opcodeTable["cvtps2pi"] = 440; - opcodeTable["cvtsd2si"] = 441; - opcodeTable["cvtsd2ss"] = 442; - opcodeTable["cvtsi2sd"] = 443; - opcodeTable["cvtsi2ss"] = 444; - opcodeTable["cvtss2sd"] = 445; - opcodeTable["cvtss2si"] = 446; - opcodeTable["cvttpd2dq"] = 447; - opcodeTable["cvttpd2pi"] = 448; - opcodeTable["cvttps2dq"] = 449; - opcodeTable["cvttps2pi"] = 450; - opcodeTable["cvttsd2si"] = 451; - opcodeTable["cvttss2si"] = 452; - opcodeTable["divpd"] = 453; - opcodeTable["divps"] = 454; - opcodeTable["divsd"] = 455; - opcodeTable["divss"] = 456; - opcodeTable["dppd"] = 457; - opcodeTable["dpps"] = 458; - opcodeTable["hsubpd"] = 459; - opcodeTable["hsubps"] = 460; - opcodeTable["insertps"] = 461; - opcodeTable["lddqu"] = 462; - opcodeTable["maskmovdqu"] = 463; - opcodeTable["maskmovq"] = 464; - opcodeTable["maxpd"] = 465; - opcodeTable["maxps"] = 466; - opcodeTable["maxsd"] = 467; - opcodeTable["maxss"] = 468; - opcodeTable["mfence"] = 469; - opcodeTable["pause"] = 470; - opcodeTable["minpd"] = 471; - opcodeTable["minps"] = 472; - opcodeTable["minsd"] = 473; - opcodeTable["minss"] = 474; - opcodeTable["monitor"] = 475; - opcodeTable["movapd"] = 476; - opcodeTable["movaps"] = 477; - opcodeTable["movd"] = 478; - opcodeTable["movq"] = 479; - opcodeTable["movddup"] = 480; - opcodeTable["movdq2q"] = 481; - opcodeTable["movdqa"] = 482; - opcodeTable["movdqu"] = 483; - opcodeTable["movhlps"] = 484; - opcodeTable["movhpd"] = 485; - opcodeTable["movhps"] = 486; - opcodeTable["movlhps"] = 487; - opcodeTable["movlpd"] = 488; - opcodeTable["movlps"] = 489; - opcodeTable["movmskpd"] = 490; - opcodeTable["movmskps"] = 491; - opcodeTable["movntdq"] = 492; - opcodeTable["movnti"] = 493; - opcodeTable["movntpd"] = 494; - opcodeTable["movntd"] = 495; - opcodeTable["movntq"] = 496; - opcodeTable["movq2dq"] = 497; - opcodeTable["movshdup"] = 498; - opcodeTable["movsldup"] = 499; - opcodeTable["movss"] = 500; - opcodeTable["movupd"] = 501; - opcodeTable["movups"] = 502; - opcodeTable["mpsadbw"] = 503; - opcodeTable["mulpd"] = 504; - opcodeTable["mulps"] = 505; - opcodeTable["mulsd"] = 506; - opcodeTable["mulss"] = 507; - opcodeTable["orpd"] = 508; - opcodeTable["orps"] = 509; - opcodeTable["packssdw"] = 510; - opcodeTable["packsswb"] = 511; - opcodeTable["packusdw"] = 512; - opcodeTable["paddb"] = 513; - opcodeTable["paddd"] = 514; - opcodeTable["paddq"] = 515; - opcodeTable["paddsw"] = 516; - opcodeTable["paddusb"] = 517; - opcodeTable["paddusw"] = 518; - opcodeTable["paddw"] = 519; - opcodeTable["palignr"] = 520; - opcodeTable["pand"] = 521; - opcodeTable["pandn"] = 522; - opcodeTable["pavgb"] = 523; - opcodeTable["pavgw"] = 524; - opcodeTable["pblendw"] = 525; - opcodeTable["pcmpeqb"] = 526; - opcodeTable["pcmpeqd"] = 527; - opcodeTable["pcmpeqw"] = 528; - opcodeTable["pcmpestri"] = 529; - opcodeTable["pcmpestrm"] = 530; - opcodeTable["pcmpgtb"] = 531; - opcodeTable["pcmpgtd"] = 532; - opcodeTable["pcmpgtw"] = 533; - opcodeTable["pextrb"] = 534; - opcodeTable["pextrd"] = 535; - opcodeTable["pextrq"] = 536; - opcodeTable["pextrw"] = 537; - opcodeTable["pinsrb"] = 538; - opcodeTable["pinsrd"] = 539; - opcodeTable["pinsrq"] = 540; - opcodeTable["pinsrw"] = 541; - opcodeTable["pmaddwd"] = 542; - opcodeTable["pmaxsw"] = 543; - opcodeTable["pmaxub"] = 544; - opcodeTable["pminsw"] = 545; - opcodeTable["pminub"] = 546; - opcodeTable["pmovmskb"] = 547; - opcodeTable["pmulhuw"] = 548; - opcodeTable["pmulhw"] = 549; - opcodeTable["pmullw"] = 550; - opcodeTable["pmuludq"] = 551; - opcodeTable["psadbw"] = 552; - opcodeTable["pshufd"] = 553; - opcodeTable["pshufhw"] = 554; - opcodeTable["pshuflw"] = 555; - opcodeTable["pshufw"] = 556; - opcodeTable["pslld"] = 557; - opcodeTable["pslldq"] = 558; - opcodeTable["psllq"] = 559; - opcodeTable["psllw"] = 560; - opcodeTable["psrad"] = 561; - opcodeTable["psraw"] = 562; - opcodeTable["psrld"] = 563; - opcodeTable["psrldq"] = 564; - opcodeTable["psrlq"] = 565; - opcodeTable["psrlw"] = 566; - opcodeTable["psubb"] = 567; - opcodeTable["psubd"] = 568; - opcodeTable["psubq"] = 569; - opcodeTable["psubsb"] = 570; - opcodeTable["psubsw"] = 571; - opcodeTable["psubusb"] = 572; - opcodeTable["psubusw"] = 573; - opcodeTable["punpckhbw"] = 574; - opcodeTable["punpckhdq"] = 575; - opcodeTable["punpckhqdq"] = 576; - opcodeTable["punpckhwd"] = 577; - opcodeTable["punpcklbw"] = 578; - opcodeTable["punpckldq"] = 579; - opcodeTable["punpcklqdq"] = 580; - opcodeTable["punpcklwd"] = 581; - opcodeTable["pxor"] = 582; - opcodeTable["rcpps"] = 583; - opcodeTable["rcpss"] = 584; - opcodeTable["roundpd"] = 585; - opcodeTable["roundps"] = 586; - opcodeTable["roundsd"] = 587; - opcodeTable["roundss"] = 588; - opcodeTable["rsqrtps"] = 589; - opcodeTable["rsqrtss"] = 590; - opcodeTable["shufpd"] = 591; - opcodeTable["shufps"] = 592; - opcodeTable["sqrtpd"] = 593; - opcodeTable["sqrtps"] = 594; - opcodeTable["sqrtsd"] = 595; - opcodeTable["sqrtss"] = 596; - opcodeTable["subpd"] = 597; - opcodeTable["subps"] = 598; - opcodeTable["subsd"] = 599; - opcodeTable["subss"] = 600; - opcodeTable["ucomisd"] = 601; - opcodeTable["ucomiss"] = 602; - opcodeTable["unpckhpd"] = 603; - opcodeTable["unpckhps"] = 604; - opcodeTable["unpcklpd"] = 605; - opcodeTable["unpcklps"] = 606; - opcodeTable["xorpd"] = 607; - opcodeTable["xorps"] = 608; - opcodeTable["invept"] = 609; - opcodeTable["invvpid"] = 610; - opcodeTable["vmcall"] = 611; - opcodeTable["vmclear"] = 612; - opcodeTable["vmlaunch"] = 613; - opcodeTable["vmptrld"] = 614; - opcodeTable["vmptrst"] = 615; - opcodeTable["vmread"] = 616; - opcodeTable["vmresume"] = 617; - opcodeTable["vmwrite"] = 618; - opcodeTable["vmxoff"] = 619; - opcodeTable["vmxon"] = 620; - prefixTable["a16"] = 0; - prefixTable["a32"] = 1; - prefixTable["lock"] = 2; - prefixTable["o16"] = 3; - prefixTable["o32"] = 4; - prefixTable["rep"] = 5; - prefixTable["repe"] = 6; - prefixTable["repne"] = 7; - prefixTable["repnz"] = 8; - prefixTable["repz"] = 9; + bits.SetBigEndian(IsBigEndian()); + memset(&stateVars, 0, sizeof(stateVars)); + stateVars[0] = 16; + tokenTable[""] = 0; + tokenTable["*"] = 5; + tokenTable["+"] = 4; + tokenTable[","] = 7; + tokenTable[":"] = 3; + tokenTable["["] = 1; + tokenTable["]"] = 2; + tokenTable["byte"] = 11; + tokenTable["dword"] = 9; + tokenTable["far"] = 15; + tokenTable["near"] = 14; + tokenTable["qword"] = 10; + tokenTable["short"] = 13; + tokenTable["tword"] = 12; + tokenTable["word"] = 8; + tokenTable["al"] = 1000; + tokenTable["ah"] = 1001; + tokenTable["ax"] = 1002; + tokenTable["eax"] = 1003; + tokenTable["rax"] = 1004; + tokenTable["r8b"] = 1005; + tokenTable["r8w"] = 1006; + tokenTable["r8d"] = 1007; + tokenTable["r8"] = 1008; + tokenTable["cl"] = 1009; + tokenTable["ch"] = 1010; + tokenTable["cx"] = 1011; + tokenTable["ecx"] = 1012; + tokenTable["rcx"] = 1013; + tokenTable["r9b"] = 1014; + tokenTable["r9w"] = 1015; + tokenTable["r9d"] = 1016; + tokenTable["r9"] = 1017; + tokenTable["dl"] = 1018; + tokenTable["dh"] = 1019; + tokenTable["dx"] = 1020; + tokenTable["edx"] = 1021; + tokenTable["rdx"] = 1022; + tokenTable["r10b"] = 1023; + tokenTable["r10w"] = 1024; + tokenTable["r10d"] = 1025; + tokenTable["r10"] = 1026; + tokenTable["bl"] = 1027; + tokenTable["bh"] = 1028; + tokenTable["bx"] = 1029; + tokenTable["ebx"] = 1030; + tokenTable["rbx"] = 1031; + tokenTable["r11b"] = 1032; + tokenTable["r11w"] = 1033; + tokenTable["r11d"] = 1034; + tokenTable["r11"] = 1035; + tokenTable["spl"] = 1036; + tokenTable["sp"] = 1037; + tokenTable["esp"] = 1038; + tokenTable["rsp"] = 1039; + tokenTable["r12b"] = 1040; + tokenTable["r12w"] = 1041; + tokenTable["r12d"] = 1042; + tokenTable["r12"] = 1043; + tokenTable["bpl"] = 1044; + tokenTable["bp"] = 1045; + tokenTable["ebp"] = 1046; + tokenTable["rbp"] = 1047; + tokenTable["r13b"] = 1048; + tokenTable["r13w"] = 1049; + tokenTable["r13d"] = 1050; + tokenTable["r13"] = 1051; + tokenTable["sil"] = 1052; + tokenTable["si"] = 1053; + tokenTable["esi"] = 1054; + tokenTable["rsi"] = 1055; + tokenTable["r14b"] = 1056; + tokenTable["r14w"] = 1057; + tokenTable["r14d"] = 1058; + tokenTable["r14"] = 1059; + tokenTable["dil"] = 1060; + tokenTable["di"] = 1061; + tokenTable["edi"] = 1062; + tokenTable["rdi"] = 1063; + tokenTable["r15b"] = 1064; + tokenTable["r15w"] = 1065; + tokenTable["r15d"] = 1066; + tokenTable["r15"] = 1067; + tokenTable["rip"] = 1068; + tokenTable["mm0"] = 1069; + tokenTable["xmm0"] = 1070; + tokenTable["xmm8"] = 1071; + tokenTable["mm1"] = 1072; + tokenTable["xmm1"] = 1073; + tokenTable["xmm9"] = 1074; + tokenTable["mm2"] = 1075; + tokenTable["xmm2"] = 1076; + tokenTable["xmm10"] = 1077; + tokenTable["mm3"] = 1078; + tokenTable["xmm3"] = 1079; + tokenTable["xmm11"] = 1080; + tokenTable["mm4"] = 1081; + tokenTable["xmm4"] = 1082; + tokenTable["xmm12"] = 1083; + tokenTable["mm5"] = 1084; + tokenTable["xmm5"] = 1085; + tokenTable["xmm13"] = 1086; + tokenTable["mm6"] = 1087; + tokenTable["xmm6"] = 1088; + tokenTable["xmm14"] = 1089; + tokenTable["mm7"] = 1090; + tokenTable["xmm7"] = 1091; + tokenTable["xmm15"] = 1092; + tokenTable["es"] = 1093; + tokenTable["cs"] = 1094; + tokenTable["ss"] = 1095; + tokenTable["ds"] = 1096; + tokenTable["fs"] = 1097; + tokenTable["gs"] = 1098; + tokenTable["st0"] = 1099; + tokenTable["st1"] = 1100; + tokenTable["st2"] = 1101; + tokenTable["st3"] = 1102; + tokenTable["st4"] = 1103; + tokenTable["st5"] = 1104; + tokenTable["st6"] = 1105; + tokenTable["st7"] = 1106; + tokenTable["cr0"] = 1107; + tokenTable["cr1"] = 1108; + tokenTable["cr2"] = 1109; + tokenTable["cr3"] = 1110; + tokenTable["cr4"] = 1111; + tokenTable["cr5"] = 1112; + tokenTable["cr6"] = 1113; + tokenTable["cr7"] = 1114; + tokenTable["dr0"] = 1115; + tokenTable["dr1"] = 1116; + tokenTable["dr2"] = 1117; + tokenTable["dr3"] = 1118; + tokenTable["dr4"] = 1119; + tokenTable["dr5"] = 1120; + tokenTable["dr6"] = 1121; + tokenTable["dr7"] = 1122; + tokenTable["tr0"] = 1123; + tokenTable["tr1"] = 1124; + tokenTable["tr2"] = 1125; + tokenTable["tr3"] = 1126; + tokenTable["tr4"] = 1127; + tokenTable["tr5"] = 1128; + tokenTable["tr6"] = 1129; + tokenTable["tr7"] = 1130; + opcodeTable["aaa"] = 32; + opcodeTable["aad"] = 33; + opcodeTable["aam"] = 34; + opcodeTable["aas"] = 35; + opcodeTable["adc"] = 36; + opcodeTable["add"] = 37; + opcodeTable["and"] = 38; + opcodeTable["arpl"] = 39; + opcodeTable["bound"] = 40; + opcodeTable["bsf"] = 41; + opcodeTable["bsr"] = 42; + opcodeTable["bswap"] = 43; + opcodeTable["bt"] = 44; + opcodeTable["btc"] = 45; + opcodeTable["btr"] = 46; + opcodeTable["bts"] = 47; + opcodeTable["call"] = 48; + opcodeTable["cbw"] = 49; + opcodeTable["cdq"] = 50; + opcodeTable["cdqe"] = 51; + opcodeTable["clc"] = 52; + opcodeTable["cld"] = 53; + opcodeTable["cli"] = 54; + opcodeTable["clts"] = 55; + opcodeTable["cmc"] = 56; + opcodeTable["cmova"] = 57; + opcodeTable["cmovae"] = 58; + opcodeTable["cmovb"] = 59; + opcodeTable["cmovbe"] = 60; + opcodeTable["cmovc"] = 61; + opcodeTable["cmove"] = 62; + opcodeTable["cmovg"] = 63; + opcodeTable["cmovge"] = 64; + opcodeTable["cmovl"] = 65; + opcodeTable["cmovle"] = 66; + opcodeTable["cmovna"] = 67; + opcodeTable["cmovnae"] = 68; + opcodeTable["cmovnb"] = 69; + opcodeTable["cmovnbe"] = 70; + opcodeTable["cmovnc"] = 71; + opcodeTable["cmovne"] = 72; + opcodeTable["cmovng"] = 73; + opcodeTable["cmovnge"] = 74; + opcodeTable["cmovnl"] = 75; + opcodeTable["cmovnle"] = 76; + opcodeTable["cmovno"] = 77; + opcodeTable["cmovnp"] = 78; + opcodeTable["cmovns"] = 79; + opcodeTable["cmovnz"] = 80; + opcodeTable["cmovo"] = 81; + opcodeTable["cmovp"] = 82; + opcodeTable["cmovpe"] = 83; + opcodeTable["cmovpo"] = 84; + opcodeTable["cmovs"] = 85; + opcodeTable["cmovz"] = 86; + opcodeTable["cmp"] = 87; + opcodeTable["cmps"] = 88; + opcodeTable["cmpsb"] = 89; + opcodeTable["cmpsw"] = 90; + opcodeTable["cmpsd"] = 91; + opcodeTable["cmpsq"] = 92; + opcodeTable["cmpxchg"] = 93; + opcodeTable["cmpxchg8b"] = 94; + opcodeTable["cmpxchg16b"] = 95; + opcodeTable["cpuid"] = 96; + opcodeTable["cqo"] = 97; + opcodeTable["cwd"] = 98; + opcodeTable["cwde"] = 99; + opcodeTable["daa"] = 100; + opcodeTable["das"] = 101; + opcodeTable["dec"] = 102; + opcodeTable["div"] = 103; + opcodeTable["enter"] = 104; + opcodeTable["esc"] = 105; + opcodeTable["f2xm1"] = 106; + opcodeTable["fabs"] = 107; + opcodeTable["fadd"] = 108; + opcodeTable["faddp"] = 109; + opcodeTable["fbld"] = 110; + opcodeTable["fbstp"] = 111; + opcodeTable["fchs"] = 112; + opcodeTable["fclex"] = 113; + opcodeTable["fnclex"] = 114; + opcodeTable["fcmovb"] = 115; + opcodeTable["fcmovbe"] = 116; + opcodeTable["fcmove"] = 117; + opcodeTable["fcmovnb"] = 118; + opcodeTable["fcmovnbe"] = 119; + opcodeTable["fcmovne"] = 120; + opcodeTable["fcmovnu"] = 121; + opcodeTable["fcmovu"] = 122; + opcodeTable["fcom"] = 123; + opcodeTable["fcomi"] = 124; + opcodeTable["fcomip"] = 125; + opcodeTable["fcomp"] = 126; + opcodeTable["fcompp"] = 127; + opcodeTable["fcos"] = 128; + opcodeTable["fdecstp"] = 129; + opcodeTable["fdisi"] = 130; + opcodeTable["fdiv"] = 131; + opcodeTable["fdivp"] = 132; + opcodeTable["fdivr"] = 133; + opcodeTable["fdivrp"] = 134; + opcodeTable["feni"] = 135; + opcodeTable["ffree"] = 136; + opcodeTable["ffreep"] = 137; + opcodeTable["fiadd"] = 138; + opcodeTable["ficom"] = 139; + opcodeTable["ficomp"] = 140; + opcodeTable["fidiv"] = 141; + opcodeTable["fidivr"] = 142; + opcodeTable["fild"] = 143; + opcodeTable["fimul"] = 144; + opcodeTable["fincstp"] = 145; + opcodeTable["finit"] = 146; + opcodeTable["fninit"] = 147; + opcodeTable["fist"] = 148; + opcodeTable["fistp"] = 149; + opcodeTable["fisub"] = 150; + opcodeTable["fisubr"] = 151; + opcodeTable["fld"] = 152; + opcodeTable["fld1"] = 153; + opcodeTable["fldcw"] = 154; + opcodeTable["fldenv"] = 155; + opcodeTable["fldl2e"] = 156; + opcodeTable["fldl2t"] = 157; + opcodeTable["fldlg2"] = 158; + opcodeTable["fldln2"] = 159; + opcodeTable["fldpi"] = 160; + opcodeTable["fldz"] = 161; + opcodeTable["fmul"] = 162; + opcodeTable["fmulp"] = 163; + opcodeTable["fnop"] = 164; + opcodeTable["fnsave"] = 165; + opcodeTable["fpatan"] = 166; + opcodeTable["fprem"] = 167; + opcodeTable["fprem1"] = 168; + opcodeTable["fptan"] = 169; + opcodeTable["frndint"] = 170; + opcodeTable["frstor"] = 171; + opcodeTable["fsave"] = 172; + opcodeTable["fscale"] = 173; + opcodeTable["fsetpm"] = 174; + opcodeTable["fsin"] = 175; + opcodeTable["fsincos"] = 176; + opcodeTable["fsqrt"] = 177; + opcodeTable["fst"] = 178; + opcodeTable["fstcw"] = 179; + opcodeTable["fnstcw"] = 180; + opcodeTable["fstenv"] = 181; + opcodeTable["fnstenv"] = 182; + opcodeTable["fstp"] = 183; + opcodeTable["fstsw"] = 184; + opcodeTable["fnstsw"] = 185; + opcodeTable["fsub"] = 186; + opcodeTable["fsubp"] = 187; + opcodeTable["fsubr"] = 188; + opcodeTable["fsubrp"] = 189; + opcodeTable["ftst"] = 190; + opcodeTable["fucom"] = 191; + opcodeTable["fucomi"] = 192; + opcodeTable["fucomip"] = 193; + opcodeTable["fucomp"] = 194; + opcodeTable["fucompp"] = 195; + opcodeTable["fwait"] = 196; + opcodeTable["fxam"] = 197; + opcodeTable["fxch"] = 198; + opcodeTable["fxch4"] = 199; + opcodeTable["fxch7"] = 200; + opcodeTable["fxrstor"] = 201; + opcodeTable["fxsave"] = 202; + opcodeTable["fxtract"] = 203; + opcodeTable["fyl2x"] = 204; + opcodeTable["fyl2xp1"] = 205; + opcodeTable["hlt"] = 206; + opcodeTable["icebp"] = 207; + opcodeTable["idiv"] = 208; + opcodeTable["imul"] = 209; + opcodeTable["in"] = 210; + opcodeTable["ins"] = 211; + opcodeTable["insb"] = 212; + opcodeTable["insw"] = 213; + opcodeTable["insd"] = 214; + opcodeTable["inc"] = 215; + opcodeTable["int"] = 216; + opcodeTable["int1"] = 217; + opcodeTable["int3"] = 218; + opcodeTable["into"] = 219; + opcodeTable["invd"] = 220; + opcodeTable["invlpg"] = 221; + opcodeTable["iret"] = 222; + opcodeTable["iretw"] = 223; + opcodeTable["iretd"] = 224; + opcodeTable["iretq"] = 225; + opcodeTable["ja"] = 226; + opcodeTable["jae"] = 227; + opcodeTable["jb"] = 228; + opcodeTable["jbe"] = 229; + opcodeTable["jc"] = 230; + opcodeTable["jcxz"] = 231; + opcodeTable["jecxz"] = 232; + opcodeTable["je"] = 233; + opcodeTable["jg"] = 234; + opcodeTable["jge"] = 235; + opcodeTable["jl"] = 236; + opcodeTable["jle"] = 237; + opcodeTable["jmp"] = 238; + opcodeTable["jna"] = 239; + opcodeTable["jnae"] = 240; + opcodeTable["jnb"] = 241; + opcodeTable["jnbe"] = 242; + opcodeTable["jnc"] = 243; + opcodeTable["jne"] = 244; + opcodeTable["jng"] = 245; + opcodeTable["jnge"] = 246; + opcodeTable["jnl"] = 247; + opcodeTable["jnle"] = 248; + opcodeTable["jno"] = 249; + opcodeTable["jnp"] = 250; + opcodeTable["jns"] = 251; + opcodeTable["jnz"] = 252; + opcodeTable["jo"] = 253; + opcodeTable["jp"] = 254; + opcodeTable["jpe"] = 255; + opcodeTable["jpo"] = 256; + opcodeTable["js"] = 257; + opcodeTable["jz"] = 258; + opcodeTable["lahf"] = 259; + opcodeTable["lar"] = 260; + opcodeTable["lds"] = 261; + opcodeTable["lea"] = 262; + opcodeTable["leave"] = 263; + opcodeTable["les"] = 264; + opcodeTable["lfence"] = 265; + opcodeTable["lfs"] = 266; + opcodeTable["lgdt"] = 267; + opcodeTable["lgs"] = 268; + opcodeTable["lidt"] = 269; + opcodeTable["lldt"] = 270; + opcodeTable["lmsw"] = 271; + opcodeTable["lods"] = 272; + opcodeTable["lodsb"] = 273; + opcodeTable["lodsw"] = 274; + opcodeTable["lodsd"] = 275; + opcodeTable["lodsq"] = 276; + opcodeTable["loop"] = 277; + opcodeTable["loope"] = 278; + opcodeTable["loopne"] = 279; + opcodeTable["loopnz"] = 280; + opcodeTable["loopz"] = 281; + opcodeTable["lsl"] = 282; + opcodeTable["lss"] = 283; + opcodeTable["ltr"] = 284; + opcodeTable["mov"] = 285; + opcodeTable["movs"] = 286; + opcodeTable["movbe"] = 287; + opcodeTable["movsb"] = 288; + opcodeTable["movsw"] = 289; + opcodeTable["movsd"] = 290; + opcodeTable["movsq"] = 291; + opcodeTable["movsx"] = 292; + opcodeTable["movzx"] = 293; + opcodeTable["movsxd"] = 294; + opcodeTable["mul"] = 295; + opcodeTable["neg"] = 296; + opcodeTable["nop"] = 297; + opcodeTable["not"] = 298; + opcodeTable["or"] = 299; + opcodeTable["out"] = 300; + opcodeTable["outs"] = 301; + opcodeTable["outsb"] = 302; + opcodeTable["outsw"] = 303; + opcodeTable["outsd"] = 304; + opcodeTable["pop"] = 305; + opcodeTable["popa"] = 306; + opcodeTable["popaw"] = 307; + opcodeTable["popad"] = 308; + opcodeTable["popcnt"] = 309; + opcodeTable["popf"] = 310; + opcodeTable["popfw"] = 311; + opcodeTable["popfd"] = 312; + opcodeTable["popfq"] = 313; + opcodeTable["prefetchnta"] = 314; + opcodeTable["prefetcht0"] = 315; + opcodeTable["prefetcht1"] = 316; + opcodeTable["prefetcht2"] = 317; + opcodeTable["push"] = 318; + opcodeTable["pusha"] = 319; + opcodeTable["pushaw"] = 320; + opcodeTable["pushad"] = 321; + opcodeTable["pushf"] = 322; + opcodeTable["pushfw"] = 323; + opcodeTable["pushfd"] = 324; + opcodeTable["pushfq"] = 325; + opcodeTable["rcl"] = 326; + opcodeTable["rcr"] = 327; + opcodeTable["rdmsr"] = 328; + opcodeTable["rdpmc"] = 329; + opcodeTable["rdtsc"] = 330; + opcodeTable["ret"] = 331; + opcodeTable["retf"] = 332; + opcodeTable["rol"] = 333; + opcodeTable["ror"] = 334; + opcodeTable["rsm"] = 335; + opcodeTable["sahf"] = 336; + opcodeTable["sal"] = 337; + opcodeTable["sar"] = 338; + opcodeTable["sbb"] = 339; + opcodeTable["scas"] = 340; + opcodeTable["scasb"] = 341; + opcodeTable["scasw"] = 342; + opcodeTable["scasd"] = 343; + opcodeTable["scasq"] = 344; + opcodeTable["seta"] = 345; + opcodeTable["setae"] = 346; + opcodeTable["setb"] = 347; + opcodeTable["setbe"] = 348; + opcodeTable["setc"] = 349; + opcodeTable["sete"] = 350; + opcodeTable["setg"] = 351; + opcodeTable["setge"] = 352; + opcodeTable["setl"] = 353; + opcodeTable["setle"] = 354; + opcodeTable["setna"] = 355; + opcodeTable["setnae"] = 356; + opcodeTable["setnb"] = 357; + opcodeTable["setnbe"] = 358; + opcodeTable["setnc"] = 359; + opcodeTable["setne"] = 360; + opcodeTable["setng"] = 361; + opcodeTable["setnge"] = 362; + opcodeTable["setnl"] = 363; + opcodeTable["setnle"] = 364; + opcodeTable["setno"] = 365; + opcodeTable["setnp"] = 366; + opcodeTable["setns"] = 367; + opcodeTable["setnz"] = 368; + opcodeTable["seto"] = 369; + opcodeTable["setp"] = 370; + opcodeTable["setpe"] = 371; + opcodeTable["setpo"] = 372; + opcodeTable["sets"] = 373; + opcodeTable["setz"] = 374; + opcodeTable["sfence"] = 375; + opcodeTable["sgdt"] = 376; + opcodeTable["shl"] = 377; + opcodeTable["shld"] = 378; + opcodeTable["shr"] = 379; + opcodeTable["shrd"] = 380; + opcodeTable["sidt"] = 381; + opcodeTable["sldt"] = 382; + opcodeTable["smsw"] = 383; + opcodeTable["stc"] = 384; + opcodeTable["std"] = 385; + opcodeTable["sti"] = 386; + opcodeTable["stos"] = 387; + opcodeTable["stosb"] = 388; + opcodeTable["stosw"] = 389; + opcodeTable["stosd"] = 390; + opcodeTable["stosq"] = 391; + opcodeTable["str"] = 392; + opcodeTable["sub"] = 393; + opcodeTable["syscall"] = 394; + opcodeTable["sysenter"] = 395; + opcodeTable["sysexit"] = 396; + opcodeTable["sysret"] = 397; + opcodeTable["test"] = 398; + opcodeTable["ud2"] = 399; + opcodeTable["verr"] = 400; + opcodeTable["verw"] = 401; + opcodeTable["wait"] = 402; + opcodeTable["wbinvd"] = 403; + opcodeTable["wrmsr"] = 404; + opcodeTable["xadd"] = 405; + opcodeTable["xchg"] = 406; + opcodeTable["xlat"] = 407; + opcodeTable["xlatb"] = 408; + opcodeTable["xor"] = 409; + opcodeTable["xrstor"] = 410; + opcodeTable["xrstor64"] = 411; + opcodeTable["xsave"] = 412; + opcodeTable["xsave64"] = 413; + opcodeTable["xsetbv"] = 414; + opcodeTable["addpd"] = 415; + opcodeTable["addps"] = 416; + opcodeTable["addsd"] = 417; + opcodeTable["addss"] = 418; + opcodeTable["addsubpd"] = 419; + opcodeTable["addsubps"] = 420; + opcodeTable["andnpd"] = 421; + opcodeTable["andnps"] = 422; + opcodeTable["andpd"] = 423; + opcodeTable["andps"] = 424; + opcodeTable["blendpd"] = 425; + opcodeTable["blendps"] = 426; + opcodeTable["cmppd"] = 427; + opcodeTable["cmpps"] = 428; + opcodeTable["comisd"] = 429; + opcodeTable["comiss"] = 430; + opcodeTable["cvtdq2pd"] = 431; + opcodeTable["cvtdq2ps"] = 432; + opcodeTable["cvtpd2dq"] = 433; + opcodeTable["cvtpd2pi"] = 434; + opcodeTable["cvtpd2ps"] = 435; + opcodeTable["cvtpi2pd"] = 436; + opcodeTable["cvtpi2ps"] = 437; + opcodeTable["cvtps2dq"] = 438; + opcodeTable["cvtps2pd"] = 439; + opcodeTable["cvtps2pi"] = 440; + opcodeTable["cvtsd2si"] = 441; + opcodeTable["cvtsd2ss"] = 442; + opcodeTable["cvtsi2sd"] = 443; + opcodeTable["cvtsi2ss"] = 444; + opcodeTable["cvtss2sd"] = 445; + opcodeTable["cvtss2si"] = 446; + opcodeTable["cvttpd2dq"] = 447; + opcodeTable["cvttpd2pi"] = 448; + opcodeTable["cvttps2dq"] = 449; + opcodeTable["cvttps2pi"] = 450; + opcodeTable["cvttsd2si"] = 451; + opcodeTable["cvttss2si"] = 452; + opcodeTable["divpd"] = 453; + opcodeTable["divps"] = 454; + opcodeTable["divsd"] = 455; + opcodeTable["divss"] = 456; + opcodeTable["dppd"] = 457; + opcodeTable["dpps"] = 458; + opcodeTable["hsubpd"] = 459; + opcodeTable["hsubps"] = 460; + opcodeTable["insertps"] = 461; + opcodeTable["lddqu"] = 462; + opcodeTable["maskmovdqu"] = 463; + opcodeTable["maskmovq"] = 464; + opcodeTable["maxpd"] = 465; + opcodeTable["maxps"] = 466; + opcodeTable["maxsd"] = 467; + opcodeTable["maxss"] = 468; + opcodeTable["mfence"] = 469; + opcodeTable["pause"] = 470; + opcodeTable["minpd"] = 471; + opcodeTable["minps"] = 472; + opcodeTable["minsd"] = 473; + opcodeTable["minss"] = 474; + opcodeTable["monitor"] = 475; + opcodeTable["movapd"] = 476; + opcodeTable["movaps"] = 477; + opcodeTable["movd"] = 478; + opcodeTable["movq"] = 479; + opcodeTable["movddup"] = 480; + opcodeTable["movdq2q"] = 481; + opcodeTable["movdqa"] = 482; + opcodeTable["movdqu"] = 483; + opcodeTable["movhlps"] = 484; + opcodeTable["movhpd"] = 485; + opcodeTable["movhps"] = 486; + opcodeTable["movlhps"] = 487; + opcodeTable["movlpd"] = 488; + opcodeTable["movlps"] = 489; + opcodeTable["movmskpd"] = 490; + opcodeTable["movmskps"] = 491; + opcodeTable["movntdq"] = 492; + opcodeTable["movnti"] = 493; + opcodeTable["movntpd"] = 494; + opcodeTable["movntd"] = 495; + opcodeTable["movntq"] = 496; + opcodeTable["movq2dq"] = 497; + opcodeTable["movshdup"] = 498; + opcodeTable["movsldup"] = 499; + opcodeTable["movss"] = 500; + opcodeTable["movupd"] = 501; + opcodeTable["movups"] = 502; + opcodeTable["mpsadbw"] = 503; + opcodeTable["mulpd"] = 504; + opcodeTable["mulps"] = 505; + opcodeTable["mulsd"] = 506; + opcodeTable["mulss"] = 507; + opcodeTable["orpd"] = 508; + opcodeTable["orps"] = 509; + opcodeTable["packssdw"] = 510; + opcodeTable["packsswb"] = 511; + opcodeTable["packusdw"] = 512; + opcodeTable["paddb"] = 513; + opcodeTable["paddd"] = 514; + opcodeTable["paddq"] = 515; + opcodeTable["paddsw"] = 516; + opcodeTable["paddusb"] = 517; + opcodeTable["paddusw"] = 518; + opcodeTable["paddw"] = 519; + opcodeTable["palignr"] = 520; + opcodeTable["pand"] = 521; + opcodeTable["pandn"] = 522; + opcodeTable["pavgb"] = 523; + opcodeTable["pavgw"] = 524; + opcodeTable["pblendw"] = 525; + opcodeTable["pcmpeqb"] = 526; + opcodeTable["pcmpeqd"] = 527; + opcodeTable["pcmpeqw"] = 528; + opcodeTable["pcmpestri"] = 529; + opcodeTable["pcmpestrm"] = 530; + opcodeTable["pcmpgtb"] = 531; + opcodeTable["pcmpgtd"] = 532; + opcodeTable["pcmpgtw"] = 533; + opcodeTable["pextrb"] = 534; + opcodeTable["pextrd"] = 535; + opcodeTable["pextrq"] = 536; + opcodeTable["pextrw"] = 537; + opcodeTable["pinsrb"] = 538; + opcodeTable["pinsrd"] = 539; + opcodeTable["pinsrq"] = 540; + opcodeTable["pinsrw"] = 541; + opcodeTable["pmaddwd"] = 542; + opcodeTable["pmaxsw"] = 543; + opcodeTable["pmaxub"] = 544; + opcodeTable["pminsw"] = 545; + opcodeTable["pminub"] = 546; + opcodeTable["pmovmskb"] = 547; + opcodeTable["pmulhuw"] = 548; + opcodeTable["pmulhw"] = 549; + opcodeTable["pmullw"] = 550; + opcodeTable["pmuludq"] = 551; + opcodeTable["psadbw"] = 552; + opcodeTable["pshufd"] = 553; + opcodeTable["pshufhw"] = 554; + opcodeTable["pshuflw"] = 555; + opcodeTable["pshufw"] = 556; + opcodeTable["pslld"] = 557; + opcodeTable["pslldq"] = 558; + opcodeTable["psllq"] = 559; + opcodeTable["psllw"] = 560; + opcodeTable["psrad"] = 561; + opcodeTable["psraw"] = 562; + opcodeTable["psrld"] = 563; + opcodeTable["psrldq"] = 564; + opcodeTable["psrlq"] = 565; + opcodeTable["psrlw"] = 566; + opcodeTable["psubb"] = 567; + opcodeTable["psubd"] = 568; + opcodeTable["psubq"] = 569; + opcodeTable["psubsb"] = 570; + opcodeTable["psubsw"] = 571; + opcodeTable["psubusb"] = 572; + opcodeTable["psubusw"] = 573; + opcodeTable["punpckhbw"] = 574; + opcodeTable["punpckhdq"] = 575; + opcodeTable["punpckhqdq"] = 576; + opcodeTable["punpckhwd"] = 577; + opcodeTable["punpcklbw"] = 578; + opcodeTable["punpckldq"] = 579; + opcodeTable["punpcklqdq"] = 580; + opcodeTable["punpcklwd"] = 581; + opcodeTable["pxor"] = 582; + opcodeTable["rcpps"] = 583; + opcodeTable["rcpss"] = 584; + opcodeTable["roundpd"] = 585; + opcodeTable["roundps"] = 586; + opcodeTable["roundsd"] = 587; + opcodeTable["roundss"] = 588; + opcodeTable["rsqrtps"] = 589; + opcodeTable["rsqrtss"] = 590; + opcodeTable["shufpd"] = 591; + opcodeTable["shufps"] = 592; + opcodeTable["sqrtpd"] = 593; + opcodeTable["sqrtps"] = 594; + opcodeTable["sqrtsd"] = 595; + opcodeTable["sqrtss"] = 596; + opcodeTable["subpd"] = 597; + opcodeTable["subps"] = 598; + opcodeTable["subsd"] = 599; + opcodeTable["subss"] = 600; + opcodeTable["ucomisd"] = 601; + opcodeTable["ucomiss"] = 602; + opcodeTable["unpckhpd"] = 603; + opcodeTable["unpckhps"] = 604; + opcodeTable["unpcklpd"] = 605; + opcodeTable["unpcklps"] = 606; + opcodeTable["xorpd"] = 607; + opcodeTable["xorps"] = 608; + opcodeTable["invept"] = 609; + opcodeTable["invvpid"] = 610; + opcodeTable["vmcall"] = 611; + opcodeTable["vmclear"] = 612; + opcodeTable["vmlaunch"] = 613; + opcodeTable["vmptrld"] = 614; + opcodeTable["vmptrst"] = 615; + opcodeTable["vmread"] = 616; + opcodeTable["vmresume"] = 617; + opcodeTable["vmwrite"] = 618; + opcodeTable["vmxoff"] = 619; + opcodeTable["vmxon"] = 620; + prefixTable["a16"] = 0; + prefixTable["a32"] = 1; + prefixTable["lock"] = 2; + prefixTable["o16"] = 3; + prefixTable["o32"] = 4; + prefixTable["rep"] = 5; + prefixTable["repe"] = 6; + prefixTable["repne"] = 7; + prefixTable["repnz"] = 8; + prefixTable["repz"] = 9; } -void x64Parser::TokenFunc4(x64Operand& operand, int tokenPos) { operand.addressCoding = 0; } -x64Token x64Parser::tokenBranches3[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc4, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc9(x64Operand& operand, int tokenPos) { operand.addressCoding = 1; } -x64Token x64Parser::tokenBranches8[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc9, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc200(x64Operand& operand, int tokenPos) { operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches199[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc200, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc346(x64Operand& operand, int tokenPos) { operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc199(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc345(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 0; } -x64Token x64Parser::tokenBranches198[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc199, x64Parser::tokenBranches199}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc345, x64Parser::tokenBranches345}, - {x64Token::EOT}}; -void x64Parser::TokenFunc36(x64Operand& operand, int tokenPos) { operand.addressCoding = 4; } -x64Token x64Parser::tokenBranches35[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc36, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc137(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc283(x64Operand& operand, int tokenPos) { operand.addressCoding = 28; } -x64Token x64Parser::tokenBranches282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc429(x64Operand& operand, int tokenPos) { operand.addressCoding = 43; } -x64Token x64Parser::tokenBranches428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc35(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc136(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc282(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc428(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc4, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc9(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 1; } -x64Token x64Parser::tokenBranches34[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc35, x64Parser::tokenBranches35}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc136, x64Parser::tokenBranches136}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc282, x64Parser::tokenBranches282}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc428, x64Parser::tokenBranches428}, - {x64Token::EOT}}; -void x64Parser::TokenFunc97(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches33[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches34}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc97, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc227(x64Operand& operand, int tokenPos) { operand.addressCoding = 22; } -x64Token x64Parser::tokenBranches226[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc227, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc373(x64Operand& operand, int tokenPos) { operand.addressCoding = 37; } -x64Token x64Parser::tokenBranches372[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc373, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc226(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc372(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches8[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc9, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc200(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches225[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc226, x64Parser::tokenBranches226}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc372, x64Parser::tokenBranches372}, - {x64Token::EOT}}; -void x64Parser::TokenFunc57(x64Operand& operand, int tokenPos) { operand.addressCoding = 7; } -x64Token x64Parser::tokenBranches56[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc57, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches225}, - {x64Token::EOT}}; -void x64Parser::TokenFunc170(x64Operand& operand, int tokenPos) { operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc316(x64Operand& operand, int tokenPos) { operand.addressCoding = 32; } -x64Token x64Parser::tokenBranches315[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc316, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc462(x64Operand& operand, int tokenPos) { operand.addressCoding = 47; } -x64Token x64Parser::tokenBranches461[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc462, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc56(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc169(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc315(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc461(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches199[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc200, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches55[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc56, x64Parser::tokenBranches56}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc169, x64Parser::tokenBranches169}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc315, x64Parser::tokenBranches315}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc461, x64Parser::tokenBranches461}, - {x64Token::EOT}}; -void x64Parser::TokenFunc120(x64Operand& operand, int tokenPos) { operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches54[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches55}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc120, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc257(x64Operand& operand, int tokenPos) { operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches256[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc257, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc403(x64Operand& operand, int tokenPos) { operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches402[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc403, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc256(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc402(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc199(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches255[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc256, x64Parser::tokenBranches256}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc402, x64Parser::tokenBranches402}, - {x64Token::EOT}}; -void x64Parser::TokenFunc79(x64Operand& operand, int tokenPos) { operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches78[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc79, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches255}, - {x64Token::EOT}}; -void x64Parser::TokenFunc606(x64Operand& operand, int tokenPos) { operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches605[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc606, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc702(x64Operand& operand, int tokenPos) { operand.addressCoding = 70; } -x64Token x64Parser::tokenBranches701[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc702, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc826(x64Operand& operand, int tokenPos) { operand.addressCoding = 84; } -x64Token x64Parser::tokenBranches825[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc826, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2121(x64Operand& operand, int tokenPos) { operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches2120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2121, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2680(x64Operand& operand, int tokenPos) { operand.addressCoding = 202; } -x64Token x64Parser::tokenBranches2679[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2680, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2951(x64Operand& operand, int tokenPos) { operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches2950[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2951, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2120(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2679(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2950(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc345(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2119[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2120, x64Parser::tokenBranches2120}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2679, x64Parser::tokenBranches2679}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2950, x64Parser::tokenBranches2950}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2403(x64Operand& operand, int tokenPos) { operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches2118[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2119}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2403, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2118(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches198[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc199, x64Parser::tokenBranches199 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc345, x64Parser::tokenBranches345 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc36(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 4; +} +x64Token x64Parser::tokenBranches35[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc36, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 28; +} +x64Token x64Parser::tokenBranches282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 43; +} +x64Token x64Parser::tokenBranches428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc35(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc136(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc282(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc428(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2117[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2118, x64Parser::tokenBranches2118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2130(x64Operand& operand, int tokenPos) { operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches2129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2689(x64Operand& operand, int tokenPos) { operand.addressCoding = 203; } -x64Token x64Parser::tokenBranches2688[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2689, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2960(x64Operand& operand, int tokenPos) { operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches2959[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2960, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2129(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2688(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2959(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches34[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc35, x64Parser::tokenBranches35 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc136, x64Parser::tokenBranches136 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc282, x64Parser::tokenBranches282 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc428, x64Parser::tokenBranches428 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc97(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches2128[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2129, x64Parser::tokenBranches2129}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2688, x64Parser::tokenBranches2688}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2959, x64Parser::tokenBranches2959}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2410(x64Operand& operand, int tokenPos) { operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches2116[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2117}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2128}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2410, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc605(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc701(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc825(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2116(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches33[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches34 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc97, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc227(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 22; } -x64Token x64Parser::tokenBranches604[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc605, x64Parser::tokenBranches605}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc701, x64Parser::tokenBranches701}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc825, x64Parser::tokenBranches825}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2116, x64Parser::tokenBranches2116}, - {x64Token::EOT}}; -void x64Parser::TokenFunc506(x64Operand& operand, int tokenPos) { operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches505[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc506, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches604}, - {x64Token::EOT}}; -void x64Parser::TokenFunc613(x64Operand& operand, int tokenPos) { operand.addressCoding = 67; } -x64Token x64Parser::tokenBranches612[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc613, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc709(x64Operand& operand, int tokenPos) { operand.addressCoding = 71; } -x64Token x64Parser::tokenBranches708[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc709, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc833(x64Operand& operand, int tokenPos) { operand.addressCoding = 85; } -x64Token x64Parser::tokenBranches832[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc833, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2101(x64Operand& operand, int tokenPos) { operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2100[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2101, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2660(x64Operand& operand, int tokenPos) { operand.addressCoding = 200; } -x64Token x64Parser::tokenBranches2659[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2660, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2931(x64Operand& operand, int tokenPos) { operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2930[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2931, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2100(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2659(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2930(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches226[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc227, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc373(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 37; } -x64Token x64Parser::tokenBranches2099[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2100, x64Parser::tokenBranches2100}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2659, x64Parser::tokenBranches2659}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2930, x64Parser::tokenBranches2930}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2387(x64Operand& operand, int tokenPos) { operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2098[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2099}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2098(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches372[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc373, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc226(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2097[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2098, x64Parser::tokenBranches2098}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2110(x64Operand& operand, int tokenPos) { operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2669(x64Operand& operand, int tokenPos) { operand.addressCoding = 201; } -x64Token x64Parser::tokenBranches2668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2669, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2940(x64Operand& operand, int tokenPos) { operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches2939[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2940, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2109(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2668(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2939(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc372(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2108[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2109, x64Parser::tokenBranches2109}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2668, x64Parser::tokenBranches2668}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2939, x64Parser::tokenBranches2939}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2394(x64Operand& operand, int tokenPos) { operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2096[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2097}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2108}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2394, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2219(x64Operand& operand, int tokenPos) { operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches2218[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2219, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2631(x64Operand& operand, int tokenPos) { operand.addressCoding = 198; } -x64Token x64Parser::tokenBranches2630[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2631, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3009(x64Operand& operand, int tokenPos) { operand.addressCoding = 228; } -x64Token x64Parser::tokenBranches3008[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3009, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2218(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2630(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3008(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches225[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc226, x64Parser::tokenBranches226 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc372, x64Parser::tokenBranches372 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc57(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 7; +} +x64Token x64Parser::tokenBranches56[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc57, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches225 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 17; +} +x64Token x64Parser::tokenBranches169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc316(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 32; +} +x64Token x64Parser::tokenBranches315[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc316, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc462(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 47; +} +x64Token x64Parser::tokenBranches461[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc462, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc56(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc169(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc315(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc461(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2217[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2218, x64Parser::tokenBranches2218}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2630, x64Parser::tokenBranches2630}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3008, x64Parser::tokenBranches3008}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2449(x64Operand& operand, int tokenPos) { operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches2216[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2217}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2449, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc612(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc708(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc832(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2096(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches55[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc56, x64Parser::tokenBranches56 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc169, x64Parser::tokenBranches169 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc315, x64Parser::tokenBranches315 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc461, x64Parser::tokenBranches461 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc120(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 17; } -x64Token x64Parser::tokenBranches611[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2216}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc612, x64Parser::tokenBranches612}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc708, x64Parser::tokenBranches708}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc832, x64Parser::tokenBranches832}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2096, x64Parser::tokenBranches2096}, - {x64Token::EOT}}; -void x64Parser::TokenFunc975(x64Operand& operand, int tokenPos) { operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches974[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc975, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc984(x64Operand& operand, int tokenPos) { operand.addressCoding = 100; } -x64Token x64Parser::tokenBranches983[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc984, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc993(x64Operand& operand, int tokenPos) { operand.addressCoding = 101; } -x64Token x64Parser::tokenBranches992[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc993, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc974(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc983(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc992(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches54[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches55 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc120, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc257(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches973[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc974, x64Parser::tokenBranches974}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc983, x64Parser::tokenBranches983}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc992, x64Parser::tokenBranches992}, - {x64Token::EOT}}; -void x64Parser::TokenFunc966(x64Operand& operand, int tokenPos) { operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches965[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc966, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches973}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1103(x64Operand& operand, int tokenPos) { operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1102[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1103, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1112(x64Operand& operand, int tokenPos) { operand.addressCoding = 109; } -x64Token x64Parser::tokenBranches1111[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1112, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1121(x64Operand& operand, int tokenPos) { operand.addressCoding = 110; } -x64Token x64Parser::tokenBranches1120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1121, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1102(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1111(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1120(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches256[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc257, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc403(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches1101[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1102, x64Parser::tokenBranches1102}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1111, x64Parser::tokenBranches1111}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1120, x64Parser::tokenBranches1120}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1094(x64Operand& operand, int tokenPos) { operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1093[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1094, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1101}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1480(x64Operand& operand, int tokenPos) { operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches1479[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1480, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1489(x64Operand& operand, int tokenPos) { operand.addressCoding = 135; } -x64Token x64Parser::tokenBranches1488[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1489, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1479(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1488(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches402[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc403, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc256(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1478[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1479, x64Parser::tokenBranches1479}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1488, x64Parser::tokenBranches1488}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1471(x64Operand& operand, int tokenPos) { operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches1470[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1471, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1478}, - {x64Token::EOT}}; -void x64Parser::TokenFunc965(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1093(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1470(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc402(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches964[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc965, x64Parser::tokenBranches965}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1093, x64Parser::tokenBranches1093}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1470, x64Parser::tokenBranches1470}, - {x64Token::EOT}}; -void x64Parser::TokenFunc511(x64Operand& operand, int tokenPos) { operand.addressCoding = 58; } -x64Token x64Parser::tokenBranches510[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc511, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches611}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches964}, - {x64Token::EOT}}; -void x64Parser::TokenFunc653(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches652[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc653, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc777(x64Operand& operand, int tokenPos) { operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches776[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc777, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc901(x64Operand& operand, int tokenPos) { operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc901, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc652(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc776(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc900(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches255[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc256, x64Parser::tokenBranches256 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc402, x64Parser::tokenBranches402 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc79(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches651[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc652, x64Parser::tokenBranches652}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc776, x64Parser::tokenBranches776}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc900, x64Parser::tokenBranches900}, - {x64Token::EOT}}; -void x64Parser::TokenFunc538(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches537[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc538, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches651}, - {x64Token::EOT}}; -void x64Parser::TokenFunc644(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches643[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc644, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc768(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches767[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc768, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc892(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches891[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc892, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2300(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2832(x64Operand& operand, int tokenPos) { operand.addressCoding = 214; } -x64Token x64Parser::tokenBranches2831[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2832, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3130(x64Operand& operand, int tokenPos) { operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches3129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2299(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2831(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3129(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches78[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc79, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches255 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc606(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches2298[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2299, x64Parser::tokenBranches2299}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2831, x64Parser::tokenBranches2831}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3129, x64Parser::tokenBranches3129}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2544(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2297[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2298}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2544, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2297(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches605[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc606, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc702(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 70; } -x64Token x64Parser::tokenBranches2296[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2297, x64Parser::tokenBranches2297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2309(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2308[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2309, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2841(x64Operand& operand, int tokenPos) { operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches2840[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2841, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3139(x64Operand& operand, int tokenPos) { operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches3138[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3139, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2308(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2840(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3138(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches701[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc702, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc826(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 84; } -x64Token x64Parser::tokenBranches2307[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2308, x64Parser::tokenBranches2308}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2840, x64Parser::tokenBranches2840}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3138, x64Parser::tokenBranches3138}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2551(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2295[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2296}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2307}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc643(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc767(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc891(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2295(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches825[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc826, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2121(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches536[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches537}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc643, x64Parser::tokenBranches643}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc767, x64Parser::tokenBranches767}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc891, x64Parser::tokenBranches891}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2295, x64Parser::tokenBranches2295}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1625(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1624[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1625, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1634(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches1633[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1634, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1643(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches1642[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1643, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1624(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1633(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1642(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2120[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2121, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2680(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 202; } -x64Token x64Parser::tokenBranches1623[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1624, x64Parser::tokenBranches1624}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1633, x64Parser::tokenBranches1633}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1642, x64Parser::tokenBranches1642}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1616(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1615[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1616, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1623}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1753(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1752[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1753, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1762(x64Operand& operand, int tokenPos) { operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches1761[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1762, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1771(x64Operand& operand, int tokenPos) { operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1770[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1771, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1752(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1761(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1770(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2679[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2680, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2951(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches1751[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1752, x64Parser::tokenBranches1752}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1761, x64Parser::tokenBranches1761}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1770, x64Parser::tokenBranches1770}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1744(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1743[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1744, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1751}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1899(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1898[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1899, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1908(x64Operand& operand, int tokenPos) { operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches1907[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1928(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1927[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1928, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1939(x64Operand& operand, int tokenPos) { operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches1938[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1939, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1927(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1938(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2950[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2951, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2120(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1926[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1927, x64Parser::tokenBranches1927}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1938, x64Parser::tokenBranches1938}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1917(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1917, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1926}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1898(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1907(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2679(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1897[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1916}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1898, x64Parser::tokenBranches1898}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1907, x64Parser::tokenBranches1907}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1890(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1889[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1890, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1615(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1743(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1889(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2950(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1614[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1615, x64Parser::tokenBranches1615}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1743, x64Parser::tokenBranches1743}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1889, x64Parser::tokenBranches1889}, - {x64Token::EOT}}; -void x64Parser::TokenFunc526(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches525[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc526, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches536}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1614}, - {x64Token::EOT}}; -void x64Parser::TokenFunc565(x64Operand& operand, int tokenPos) { operand.addressCoding = 64; } -x64Token x64Parser::tokenBranches564[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc565, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1231(x64Operand& operand, int tokenPos) { operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches1230[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1231, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1240(x64Operand& operand, int tokenPos) { operand.addressCoding = 118; } -x64Token x64Parser::tokenBranches1239[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1240, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1249(x64Operand& operand, int tokenPos) { operand.addressCoding = 119; } -x64Token x64Parser::tokenBranches1248[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1249, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1230(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1239(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1248(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2119[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2120, x64Parser::tokenBranches2120 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2679, x64Parser::tokenBranches2679 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2950, x64Parser::tokenBranches2950 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2403(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 176; } -x64Token x64Parser::tokenBranches1229[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1230, x64Parser::tokenBranches1230}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1239, x64Parser::tokenBranches1239}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1248, x64Parser::tokenBranches1248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1222(x64Operand& operand, int tokenPos) { operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches1221[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1222, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1229}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1359(x64Operand& operand, int tokenPos) { operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches1358[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1359, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1368(x64Operand& operand, int tokenPos) { operand.addressCoding = 127; } -x64Token x64Parser::tokenBranches1367[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1368, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1377(x64Operand& operand, int tokenPos) { operand.addressCoding = 128; } -x64Token x64Parser::tokenBranches1376[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1377, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1358(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1367(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1376(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2118[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2119 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2403, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2118(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1357[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1358, x64Parser::tokenBranches1358}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1367, x64Parser::tokenBranches1367}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1376, x64Parser::tokenBranches1376}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1350(x64Operand& operand, int tokenPos) { operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches1349[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1350, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1357}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1221(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1349(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2117[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2118, x64Parser::tokenBranches2118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 177; } -x64Token x64Parser::tokenBranches1220[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1221, x64Parser::tokenBranches1221}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1349, x64Parser::tokenBranches1349}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches1219[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1220}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3748(x64Operand& operand, int tokenPos) { operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches3747[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3748, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3757(x64Operand& operand, int tokenPos) { operand.addressCoding = 310; } -x64Token x64Parser::tokenBranches3756[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3757, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3766(x64Operand& operand, int tokenPos) { operand.addressCoding = 311; } -x64Token x64Parser::tokenBranches3765[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3766, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3747(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3756(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3765(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2689(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 203; } -x64Token x64Parser::tokenBranches3746[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3747, x64Parser::tokenBranches3747}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3756, x64Parser::tokenBranches3756}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3765, x64Parser::tokenBranches3765}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3739(x64Operand& operand, int tokenPos) { operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches3738[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3739, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3746}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3876(x64Operand& operand, int tokenPos) { operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches3875[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3876, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3885(x64Operand& operand, int tokenPos) { operand.addressCoding = 319; } -x64Token x64Parser::tokenBranches3884[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3885, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3894(x64Operand& operand, int tokenPos) { operand.addressCoding = 320; } -x64Token x64Parser::tokenBranches3893[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3894, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3875(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3884(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3893(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2688[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2689, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2960(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches3874[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3875, x64Parser::tokenBranches3875}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3884, x64Parser::tokenBranches3884}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3893, x64Parser::tokenBranches3893}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3867(x64Operand& operand, int tokenPos) { operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches3866[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3867, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3874}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3738(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3866(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2959[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2960, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2129(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3737[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3738, x64Parser::tokenBranches3738}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3866, x64Parser::tokenBranches3866}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3736[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3737}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4004(x64Operand& operand, int tokenPos) { operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches4003[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4004, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4013(x64Operand& operand, int tokenPos) { operand.addressCoding = 328; } -x64Token x64Parser::tokenBranches4012[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4013, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4022(x64Operand& operand, int tokenPos) { operand.addressCoding = 329; } -x64Token x64Parser::tokenBranches4021[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4022, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4003(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4012(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4021(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2688(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4002[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4003, x64Parser::tokenBranches4003}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4012, x64Parser::tokenBranches4012}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4021, x64Parser::tokenBranches4021}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3995(x64Operand& operand, int tokenPos) { operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches3994[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3995, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4002}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4132(x64Operand& operand, int tokenPos) { operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches4131[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4132, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4141(x64Operand& operand, int tokenPos) { operand.addressCoding = 337; } -x64Token x64Parser::tokenBranches4140[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4141, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4150(x64Operand& operand, int tokenPos) { operand.addressCoding = 338; } -x64Token x64Parser::tokenBranches4149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4131(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4140(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4149(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2959(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4130[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4131, x64Parser::tokenBranches4131}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4140, x64Parser::tokenBranches4140}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4149, x64Parser::tokenBranches4149}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4123(x64Operand& operand, int tokenPos) { operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches4122[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4123, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4130}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3994(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4122(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2128[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2129, x64Parser::tokenBranches2129 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2688, x64Parser::tokenBranches2688 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2959, x64Parser::tokenBranches2959 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2410(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 177; +} +x64Token x64Parser::tokenBranches2116[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2117 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2128 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2410, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc605(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc701(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc825(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2116(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches3993[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3994, x64Parser::tokenBranches3994}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4122, x64Parser::tokenBranches4122}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3992[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3993}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc78(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc525(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc564(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches604[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc605, x64Parser::tokenBranches605 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc701, x64Parser::tokenBranches701 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc825, x64Parser::tokenBranches825 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2116, x64Parser::tokenBranches2116 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc506(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 57; } -x64Token x64Parser::tokenBranches7[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches33}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches54}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches505}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches510}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1219}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3736}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3992}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc8, x64Parser::tokenBranches8}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc78, x64Parser::tokenBranches78}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc525, x64Parser::tokenBranches525}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc564, x64Parser::tokenBranches564}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches7}, - {x64Token::EOT}}; -void x64Parser::TokenFunc14(x64Operand& operand, int tokenPos) { operand.addressCoding = 2; } -x64Token x64Parser::tokenBranches13[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc14, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc209(x64Operand& operand, int tokenPos) { operand.addressCoding = 21; } -x64Token x64Parser::tokenBranches208[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc209, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc355(x64Operand& operand, int tokenPos) { operand.addressCoding = 36; } -x64Token x64Parser::tokenBranches354[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc355, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc208(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc354(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches505[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc506, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches604 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc613(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 67; } -x64Token x64Parser::tokenBranches207[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc208, x64Parser::tokenBranches208}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc354, x64Parser::tokenBranches354}, - {x64Token::EOT}}; -void x64Parser::TokenFunc43(x64Operand& operand, int tokenPos) { operand.addressCoding = 6; } -x64Token x64Parser::tokenBranches42[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc43, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches207}, - {x64Token::EOT}}; -void x64Parser::TokenFunc144(x64Operand& operand, int tokenPos) { operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches143[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc144, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc290(x64Operand& operand, int tokenPos) { operand.addressCoding = 29; } -x64Token x64Parser::tokenBranches289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc290, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc436(x64Operand& operand, int tokenPos) { operand.addressCoding = 44; } -x64Token x64Parser::tokenBranches435[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc436, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc42(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc143(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc289(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc435(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches612[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc613, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc709(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 71; } -x64Token x64Parser::tokenBranches41[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc42, x64Parser::tokenBranches42}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc143, x64Parser::tokenBranches143}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc289, x64Parser::tokenBranches289}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc435, x64Parser::tokenBranches435}, - {x64Token::EOT}}; -void x64Parser::TokenFunc102(x64Operand& operand, int tokenPos) { operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches40[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches41}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc218(x64Operand& operand, int tokenPos) { operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc364(x64Operand& operand, int tokenPos) { operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches363[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc364, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc217(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc363(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches708[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc709, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc833(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 85; } -x64Token x64Parser::tokenBranches216[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc217, x64Parser::tokenBranches217}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc363, x64Parser::tokenBranches363}, - {x64Token::EOT}}; -void x64Parser::TokenFunc50(x64Operand& operand, int tokenPos) { operand.addressCoding = 5; } -x64Token x64Parser::tokenBranches49[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc50, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches216}, - {x64Token::EOT}}; -void x64Parser::TokenFunc163(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches162[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc163, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc309(x64Operand& operand, int tokenPos) { operand.addressCoding = 31; } -x64Token x64Parser::tokenBranches308[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc309, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc455(x64Operand& operand, int tokenPos) { operand.addressCoding = 46; } -x64Token x64Parser::tokenBranches454[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc455, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc49(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc162(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc308(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc454(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches832[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc833, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2101(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches48[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc49, x64Parser::tokenBranches49}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc162, x64Parser::tokenBranches162}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc308, x64Parser::tokenBranches308}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc454, x64Parser::tokenBranches454}, - {x64Token::EOT}}; -void x64Parser::TokenFunc115(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches47[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches48}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc115, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc264(x64Operand& operand, int tokenPos) { operand.addressCoding = 26; } -x64Token x64Parser::tokenBranches263[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc264, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc410(x64Operand& operand, int tokenPos) { operand.addressCoding = 41; } -x64Token x64Parser::tokenBranches409[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc410, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc263(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc409(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2100[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2101, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2660(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 200; } -x64Token x64Parser::tokenBranches262[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc263, x64Parser::tokenBranches263}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc409, x64Parser::tokenBranches409}, - {x64Token::EOT}}; -void x64Parser::TokenFunc84(x64Operand& operand, int tokenPos) { operand.addressCoding = 11; } -x64Token x64Parser::tokenBranches83[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc84, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches262}, - {x64Token::EOT}}; -void x64Parser::TokenFunc592(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches591[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc592, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc716(x64Operand& operand, int tokenPos) { operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches715[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc716, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc840(x64Operand& operand, int tokenPos) { operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches839[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc840, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2161(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2160[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2161, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2720(x64Operand& operand, int tokenPos) { operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2719[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2720, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2991(x64Operand& operand, int tokenPos) { operand.addressCoding = 226; } -x64Token x64Parser::tokenBranches2990[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2991, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2160(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2719(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2990(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2659[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2660, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2931(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2159[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2160, x64Parser::tokenBranches2160}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2719, x64Parser::tokenBranches2719}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2990, x64Parser::tokenBranches2990}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2435(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2158[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2159}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2435, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2158(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2930[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2931, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2100(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2157[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2158, x64Parser::tokenBranches2158}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2170(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2729(x64Operand& operand, int tokenPos) { operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches2728[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2729, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3000(x64Operand& operand, int tokenPos) { operand.addressCoding = 227; } -x64Token x64Parser::tokenBranches2999[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3000, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2169(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2728(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2999(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2659(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2168[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2169, x64Parser::tokenBranches2169}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2728, x64Parser::tokenBranches2728}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2999, x64Parser::tokenBranches2999}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2442(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2156[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2157}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2168}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2442, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc591(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc715(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc839(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2156(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2930(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches590[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc591, x64Parser::tokenBranches591}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc715, x64Parser::tokenBranches715}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc839, x64Parser::tokenBranches839}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2156, x64Parser::tokenBranches2156}, - {x64Token::EOT}}; -void x64Parser::TokenFunc516(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches515[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc516, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches590}, - {x64Token::EOT}}; -void x64Parser::TokenFunc599(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches598[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc599, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc723(x64Operand& operand, int tokenPos) { operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches722[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc723, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc847(x64Operand& operand, int tokenPos) { operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches846[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc847, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2141(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2140[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2141, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2700(x64Operand& operand, int tokenPos) { operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches2699[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2700, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2971(x64Operand& operand, int tokenPos) { operand.addressCoding = 224; } -x64Token x64Parser::tokenBranches2970[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2971, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2140(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2699(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2970(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2099[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2100, x64Parser::tokenBranches2100 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2659, x64Parser::tokenBranches2659 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2930, x64Parser::tokenBranches2930 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2387(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 174; } -x64Token x64Parser::tokenBranches2139[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2140, x64Parser::tokenBranches2140}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2699, x64Parser::tokenBranches2699}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2970, x64Parser::tokenBranches2970}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2419(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2138[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2139}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2419, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2138(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2098[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2099 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2098(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2137[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2138, x64Parser::tokenBranches2138}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2150(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2709(x64Operand& operand, int tokenPos) { operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches2708[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2709, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2980(x64Operand& operand, int tokenPos) { operand.addressCoding = 225; } -x64Token x64Parser::tokenBranches2979[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2980, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2149(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2708(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2979(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2097[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2098, x64Parser::tokenBranches2098 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches2148[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2149, x64Parser::tokenBranches2149}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2708, x64Parser::tokenBranches2708}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2979, x64Parser::tokenBranches2979}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2426(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2136[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2137}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2148}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2426, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2228(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2227[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2228, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2640(x64Operand& operand, int tokenPos) { operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches2639[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2640, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3018(x64Operand& operand, int tokenPos) { operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches3017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2227(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2639(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3017(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 201; } -x64Token x64Parser::tokenBranches2226[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2227, x64Parser::tokenBranches2227}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2639, x64Parser::tokenBranches2639}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3017, x64Parser::tokenBranches3017}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2456(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2225[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2226}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2456, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc598(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc722(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc846(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2136(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2669, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2940(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches597[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2225}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc598, x64Parser::tokenBranches598}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc722, x64Parser::tokenBranches722}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc846, x64Parser::tokenBranches846}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2136, x64Parser::tokenBranches2136}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1009(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches1008[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1009, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1018(x64Operand& operand, int tokenPos) { operand.addressCoding = 97; } -x64Token x64Parser::tokenBranches1017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1027(x64Operand& operand, int tokenPos) { operand.addressCoding = 98; } -x64Token x64Parser::tokenBranches1026[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1027, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1008(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1017(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1026(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2939[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2940, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2109(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1007[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1008, x64Parser::tokenBranches1008}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1017, x64Parser::tokenBranches1017}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1026, x64Parser::tokenBranches1026}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1000(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches999[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1000, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1007}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1137(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1146(x64Operand& operand, int tokenPos) { operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches1145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1155(x64Operand& operand, int tokenPos) { operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches1154[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1155, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1136(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1145(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1154(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2668(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1135[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1136, x64Parser::tokenBranches1136}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1145, x64Parser::tokenBranches1145}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1154, x64Parser::tokenBranches1154}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1128(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1127[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1128, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1135}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1505(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1504[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1505, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1514(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1513[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1514, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1504(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1513(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2939(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1503[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1504, x64Parser::tokenBranches1504}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1513, x64Parser::tokenBranches1513}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1496(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1495[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1496, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1503}, - {x64Token::EOT}}; -void x64Parser::TokenFunc999(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1127(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1495(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2108[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2109, x64Parser::tokenBranches2109 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2668, x64Parser::tokenBranches2668 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2939, x64Parser::tokenBranches2939 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2394(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 175; } -x64Token x64Parser::tokenBranches998[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc999, x64Parser::tokenBranches999}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1127, x64Parser::tokenBranches1127}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1495, x64Parser::tokenBranches1495}, - {x64Token::EOT}}; -void x64Parser::TokenFunc521(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc521, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches597}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches998}, - {x64Token::EOT}}; -void x64Parser::TokenFunc669(x64Operand& operand, int tokenPos) { operand.addressCoding = 60; } -x64Token x64Parser::tokenBranches668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc669, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc793(x64Operand& operand, int tokenPos) { operand.addressCoding = 79; } -x64Token x64Parser::tokenBranches792[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc793, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc917(x64Operand& operand, int tokenPos) { operand.addressCoding = 93; } -x64Token x64Parser::tokenBranches916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc917, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc668(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc792(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc916(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2096[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2097 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2108 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2394, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2219(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 182; } -x64Token x64Parser::tokenBranches667[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc668, x64Parser::tokenBranches668}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc792, x64Parser::tokenBranches792}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc916, x64Parser::tokenBranches916}, - {x64Token::EOT}}; -void x64Parser::TokenFunc545(x64Operand& operand, int tokenPos) { operand.addressCoding = 60; } -x64Token x64Parser::tokenBranches544[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc545, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches667}, - {x64Token::EOT}}; -void x64Parser::TokenFunc660(x64Operand& operand, int tokenPos) { operand.addressCoding = 59; } -x64Token x64Parser::tokenBranches659[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc660, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc784(x64Operand& operand, int tokenPos) { operand.addressCoding = 78; } -x64Token x64Parser::tokenBranches783[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc784, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc908(x64Operand& operand, int tokenPos) { operand.addressCoding = 92; } -x64Token x64Parser::tokenBranches907[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2320(x64Operand& operand, int tokenPos) { operand.addressCoding = 189; } -x64Token x64Parser::tokenBranches2319[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2320, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2852(x64Operand& operand, int tokenPos) { operand.addressCoding = 215; } -x64Token x64Parser::tokenBranches2851[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2852, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3150(x64Operand& operand, int tokenPos) { operand.addressCoding = 240; } -x64Token x64Parser::tokenBranches3149[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3150, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2319(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2851(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3149(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2218[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2219, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2631(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 198; } -x64Token x64Parser::tokenBranches2318[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2319, x64Parser::tokenBranches2319}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2851, x64Parser::tokenBranches2851}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3149, x64Parser::tokenBranches3149}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2560(x64Operand& operand, int tokenPos) { operand.addressCoding = 189; } -x64Token x64Parser::tokenBranches2317[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2318}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2317(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2630[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2631, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3009(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 228; } -x64Token x64Parser::tokenBranches2316[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2317, x64Parser::tokenBranches2317}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2329(x64Operand& operand, int tokenPos) { operand.addressCoding = 190; } -x64Token x64Parser::tokenBranches2328[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2329, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2861(x64Operand& operand, int tokenPos) { operand.addressCoding = 216; } -x64Token x64Parser::tokenBranches2860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3159(x64Operand& operand, int tokenPos) { operand.addressCoding = 241; } -x64Token x64Parser::tokenBranches3158[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3159, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2328(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2860(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3158(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3008[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3009, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2218(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2327[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2328, x64Parser::tokenBranches2328}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2860, x64Parser::tokenBranches2860}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3158, x64Parser::tokenBranches3158}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2567(x64Operand& operand, int tokenPos) { operand.addressCoding = 190; } -x64Token x64Parser::tokenBranches2315[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2316}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2327}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2567, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc659(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc783(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc907(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2315(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2630(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches543[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches544}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc659, x64Parser::tokenBranches659}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc783, x64Parser::tokenBranches783}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc907, x64Parser::tokenBranches907}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2315, x64Parser::tokenBranches2315}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1659(x64Operand& operand, int tokenPos) { operand.addressCoding = 141; } -x64Token x64Parser::tokenBranches1658[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1659, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1668(x64Operand& operand, int tokenPos) { operand.addressCoding = 142; } -x64Token x64Parser::tokenBranches1667[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1668, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1677(x64Operand& operand, int tokenPos) { operand.addressCoding = 143; } -x64Token x64Parser::tokenBranches1676[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1677, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1658(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1667(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1676(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3008(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1657[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1658, x64Parser::tokenBranches1658}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1667, x64Parser::tokenBranches1667}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1676, x64Parser::tokenBranches1676}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1650(x64Operand& operand, int tokenPos) { operand.addressCoding = 141; } -x64Token x64Parser::tokenBranches1649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1650, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1657}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1787(x64Operand& operand, int tokenPos) { operand.addressCoding = 150; } -x64Token x64Parser::tokenBranches1786[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1787, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1796(x64Operand& operand, int tokenPos) { operand.addressCoding = 151; } -x64Token x64Parser::tokenBranches1795[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1796, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1805(x64Operand& operand, int tokenPos) { operand.addressCoding = 152; } -x64Token x64Parser::tokenBranches1804[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1805, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1786(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1795(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1804(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2217[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2218, x64Parser::tokenBranches2218 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2630, x64Parser::tokenBranches2630 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3008, x64Parser::tokenBranches3008 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2449(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 182; +} +x64Token x64Parser::tokenBranches2216[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2217 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2449, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc612(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc708(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc832(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2096(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches1785[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1786, x64Parser::tokenBranches1786}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1795, x64Parser::tokenBranches1795}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1804, x64Parser::tokenBranches1804}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1778(x64Operand& operand, int tokenPos) { operand.addressCoding = 150; } -x64Token x64Parser::tokenBranches1777[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1778, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1785}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1955(x64Operand& operand, int tokenPos) { operand.addressCoding = 161; } -x64Token x64Parser::tokenBranches1954[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1955, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1964(x64Operand& operand, int tokenPos) { operand.addressCoding = 162; } -x64Token x64Parser::tokenBranches1963[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1964, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1984(x64Operand& operand, int tokenPos) { operand.addressCoding = 163; } -x64Token x64Parser::tokenBranches1983[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1984, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1995(x64Operand& operand, int tokenPos) { operand.addressCoding = 164; } -x64Token x64Parser::tokenBranches1994[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1995, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1983(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1994(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches611[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2216 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc612, x64Parser::tokenBranches612 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc708, x64Parser::tokenBranches708 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc832, x64Parser::tokenBranches832 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2096, x64Parser::tokenBranches2096 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc975(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 99; +} +x64Token x64Parser::tokenBranches974[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc975, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc984(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 100; +} +x64Token x64Parser::tokenBranches983[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc984, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc993(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 101; +} +x64Token x64Parser::tokenBranches992[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc993, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc974(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc983(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc992(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1982[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1983, x64Parser::tokenBranches1983}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1994, x64Parser::tokenBranches1994}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1973(x64Operand& operand, int tokenPos) { operand.addressCoding = 163; } -x64Token x64Parser::tokenBranches1972[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1973, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1982}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1954(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1963(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches973[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc974, x64Parser::tokenBranches974 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc983, x64Parser::tokenBranches983 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc992, x64Parser::tokenBranches992 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc966(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 99; } -x64Token x64Parser::tokenBranches1953[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1972}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1954, x64Parser::tokenBranches1954}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1963, x64Parser::tokenBranches1963}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1946(x64Operand& operand, int tokenPos) { operand.addressCoding = 160; } -x64Token x64Parser::tokenBranches1945[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1946, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1953}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1649(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1777(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1945(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches965[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc966, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches973 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1103(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches1648[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1649, x64Parser::tokenBranches1649}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1777, x64Parser::tokenBranches1777}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1945, x64Parser::tokenBranches1945}, - {x64Token::EOT}}; -void x64Parser::TokenFunc531(x64Operand& operand, int tokenPos) { operand.addressCoding = 59; } -x64Token x64Parser::tokenBranches530[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc531, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches543}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1648}, - {x64Token::EOT}}; -void x64Parser::TokenFunc570(x64Operand& operand, int tokenPos) { operand.addressCoding = 65; } -x64Token x64Parser::tokenBranches569[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc570, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1265(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1265, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1274(x64Operand& operand, int tokenPos) { operand.addressCoding = 115; } -x64Token x64Parser::tokenBranches1273[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1274, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1283(x64Operand& operand, int tokenPos) { operand.addressCoding = 116; } -x64Token x64Parser::tokenBranches1282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1264(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1273(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1282(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1102[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1103, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1112(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 109; } -x64Token x64Parser::tokenBranches1263[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1264, x64Parser::tokenBranches1264}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1273, x64Parser::tokenBranches1273}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1282, x64Parser::tokenBranches1282}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1256(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1255[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1256, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1263}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1393(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1392[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1393, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1402(x64Operand& operand, int tokenPos) { operand.addressCoding = 124; } -x64Token x64Parser::tokenBranches1401[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1402, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1411(x64Operand& operand, int tokenPos) { operand.addressCoding = 125; } -x64Token x64Parser::tokenBranches1410[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1411, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1392(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1401(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1410(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1111[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1112, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1121(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 110; } -x64Token x64Parser::tokenBranches1391[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1392, x64Parser::tokenBranches1392}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1401, x64Parser::tokenBranches1401}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1410, x64Parser::tokenBranches1410}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1384(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1383[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1384, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1391}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1255(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1383(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1120[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1121, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1102(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1254[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1255, x64Parser::tokenBranches1255}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1383, x64Parser::tokenBranches1383}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches1253[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1254}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3782(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3781[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3782, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3791(x64Operand& operand, int tokenPos) { operand.addressCoding = 307; } -x64Token x64Parser::tokenBranches3790[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3791, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3800(x64Operand& operand, int tokenPos) { operand.addressCoding = 308; } -x64Token x64Parser::tokenBranches3799[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3800, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3781(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3790(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3799(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1111(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3780[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3781, x64Parser::tokenBranches3781}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3790, x64Parser::tokenBranches3790}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3799, x64Parser::tokenBranches3799}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3773(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3772[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3773, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3780}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3910(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3909[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3910, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3919(x64Operand& operand, int tokenPos) { operand.addressCoding = 316; } -x64Token x64Parser::tokenBranches3918[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3919, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3928(x64Operand& operand, int tokenPos) { operand.addressCoding = 317; } -x64Token x64Parser::tokenBranches3927[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3928, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3909(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3918(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3927(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1120(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3908[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3909, x64Parser::tokenBranches3909}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3918, x64Parser::tokenBranches3918}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3927, x64Parser::tokenBranches3927}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3901(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3901, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3908}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3772(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3900(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1101[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1102, x64Parser::tokenBranches1102 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1111, x64Parser::tokenBranches1111 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1120, x64Parser::tokenBranches1120 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1094(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 108; } -x64Token x64Parser::tokenBranches3771[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3772, x64Parser::tokenBranches3772}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3900, x64Parser::tokenBranches3900}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3770[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3771}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4038(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches4037[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4038, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4047(x64Operand& operand, int tokenPos) { operand.addressCoding = 325; } -x64Token x64Parser::tokenBranches4046[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4047, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4056(x64Operand& operand, int tokenPos) { operand.addressCoding = 326; } -x64Token x64Parser::tokenBranches4055[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4056, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4037(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4046(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4055(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1093[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1094, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1101 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1480(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 134; } -x64Token x64Parser::tokenBranches4036[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4037, x64Parser::tokenBranches4037}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4046, x64Parser::tokenBranches4046}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4055, x64Parser::tokenBranches4055}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4029(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches4028[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4029, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4036}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4166(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4165[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4166, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4175(x64Operand& operand, int tokenPos) { operand.addressCoding = 334; } -x64Token x64Parser::tokenBranches4174[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4175, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4184(x64Operand& operand, int tokenPos) { operand.addressCoding = 335; } -x64Token x64Parser::tokenBranches4183[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4184, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4165(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4174(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4183(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1479[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1480, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1489(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 135; } -x64Token x64Parser::tokenBranches4164[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4165, x64Parser::tokenBranches4165}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4174, x64Parser::tokenBranches4174}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4183, x64Parser::tokenBranches4183}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4157(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4156[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4157, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4164}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4028(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4156(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1488[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1489, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1479(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4027[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4028, x64Parser::tokenBranches4028}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4156, x64Parser::tokenBranches4156}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches4026[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4027}, - {x64Token::EOT}}; -void x64Parser::TokenFunc13(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc83(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc530(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc569(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1488(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches12[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches40}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches47}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches515}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches520}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1253}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3770}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4026}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc13, x64Parser::tokenBranches13}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc83, x64Parser::tokenBranches83}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc530, x64Parser::tokenBranches530}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc569, x64Parser::tokenBranches569}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches11[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches12}, - {x64Token::EOT}}; -void x64Parser::TokenFunc19(x64Operand& operand, int tokenPos) { operand.addressCoding = 3; } -x64Token x64Parser::tokenBranches18[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc19, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc236(x64Operand& operand, int tokenPos) { operand.addressCoding = 23; } -x64Token x64Parser::tokenBranches235[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc236, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc382(x64Operand& operand, int tokenPos) { operand.addressCoding = 38; } -x64Token x64Parser::tokenBranches381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc382, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc235(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc381(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1478[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1479, x64Parser::tokenBranches1479 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1488, x64Parser::tokenBranches1488 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1471(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 134; +} +x64Token x64Parser::tokenBranches1470[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1471, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1478 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc965(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1093(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1470(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches234[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc235, x64Parser::tokenBranches235}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc381, x64Parser::tokenBranches381}, - {x64Token::EOT}}; -void x64Parser::TokenFunc64(x64Operand& operand, int tokenPos) { operand.addressCoding = 8; } -x64Token x64Parser::tokenBranches63[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc64, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches234}, - {x64Token::EOT}}; -void x64Parser::TokenFunc151(x64Operand& operand, int tokenPos) { operand.addressCoding = 15; } -x64Token x64Parser::tokenBranches150[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc151, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc297(x64Operand& operand, int tokenPos) { operand.addressCoding = 30; } -x64Token x64Parser::tokenBranches296[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc297, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc443(x64Operand& operand, int tokenPos) { operand.addressCoding = 45; } -x64Token x64Parser::tokenBranches442[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc443, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc63(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc150(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc296(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc442(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches964[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc965, x64Parser::tokenBranches965 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1093, x64Parser::tokenBranches1093 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1470, x64Parser::tokenBranches1470 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc511(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 58; } -x64Token x64Parser::tokenBranches62[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc63, x64Parser::tokenBranches63}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc150, x64Parser::tokenBranches150}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc296, x64Parser::tokenBranches296}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc442, x64Parser::tokenBranches442}, - {x64Token::EOT}}; -void x64Parser::TokenFunc107(x64Operand& operand, int tokenPos) { operand.addressCoding = 15; } -x64Token x64Parser::tokenBranches61[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches62}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc107, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc245(x64Operand& operand, int tokenPos) { operand.addressCoding = 24; } -x64Token x64Parser::tokenBranches244[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc245, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc391(x64Operand& operand, int tokenPos) { operand.addressCoding = 39; } -x64Token x64Parser::tokenBranches390[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc391, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc244(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc390(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches510[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc511, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches611 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches964 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc653(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches243[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc244, x64Parser::tokenBranches244}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc390, x64Parser::tokenBranches390}, - {x64Token::EOT}}; -void x64Parser::TokenFunc71(x64Operand& operand, int tokenPos) { operand.addressCoding = 9; } -x64Token x64Parser::tokenBranches70[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc71, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches243}, - {x64Token::EOT}}; -void x64Parser::TokenFunc177(x64Operand& operand, int tokenPos) { operand.addressCoding = 18; } -x64Token x64Parser::tokenBranches176[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc177, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc323(x64Operand& operand, int tokenPos) { operand.addressCoding = 33; } -x64Token x64Parser::tokenBranches322[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc323, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc469(x64Operand& operand, int tokenPos) { operand.addressCoding = 48; } -x64Token x64Parser::tokenBranches468[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc469, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc70(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc176(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc322(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc468(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches652[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc653, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc777(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches69[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc70, x64Parser::tokenBranches70}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc176, x64Parser::tokenBranches176}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc322, x64Parser::tokenBranches322}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc468, x64Parser::tokenBranches468}, - {x64Token::EOT}}; -void x64Parser::TokenFunc125(x64Operand& operand, int tokenPos) { operand.addressCoding = 18; } -x64Token x64Parser::tokenBranches68[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches69}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc125, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc271(x64Operand& operand, int tokenPos) { operand.addressCoding = 27; } -x64Token x64Parser::tokenBranches270[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc271, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc417(x64Operand& operand, int tokenPos) { operand.addressCoding = 42; } -x64Token x64Parser::tokenBranches416[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc417, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc270(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc416(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches776[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc777, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc901(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches269[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc270, x64Parser::tokenBranches270}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc416, x64Parser::tokenBranches416}, - {x64Token::EOT}}; -void x64Parser::TokenFunc89(x64Operand& operand, int tokenPos) { operand.addressCoding = 12; } -x64Token x64Parser::tokenBranches88[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc89, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches269}, - {x64Token::EOT}}; -void x64Parser::TokenFunc730(x64Operand& operand, int tokenPos) { operand.addressCoding = 72; } -x64Token x64Parser::tokenBranches729[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc854(x64Operand& operand, int tokenPos) { operand.addressCoding = 86; } -x64Token x64Parser::tokenBranches853[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc854, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2201(x64Operand& operand, int tokenPos) { operand.addressCoding = 180; } -x64Token x64Parser::tokenBranches2200[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2201, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2760(x64Operand& operand, int tokenPos) { operand.addressCoding = 206; } -x64Token x64Parser::tokenBranches2759[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2760, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3058(x64Operand& operand, int tokenPos) { operand.addressCoding = 232; } -x64Token x64Parser::tokenBranches3057[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3058, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2200(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2759(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3057(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches900[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc901, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc652(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2199[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2200, x64Parser::tokenBranches2200}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2759, x64Parser::tokenBranches2759}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3057, x64Parser::tokenBranches3057}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2488(x64Operand& operand, int tokenPos) { operand.addressCoding = 180; } -x64Token x64Parser::tokenBranches2198[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2199}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2488, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2198(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc776(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2197[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2198, x64Parser::tokenBranches2198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2210(x64Operand& operand, int tokenPos) { operand.addressCoding = 181; } -x64Token x64Parser::tokenBranches2209[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2210, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2769(x64Operand& operand, int tokenPos) { operand.addressCoding = 207; } -x64Token x64Parser::tokenBranches2768[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2769, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3067(x64Operand& operand, int tokenPos) { operand.addressCoding = 233; } -x64Token x64Parser::tokenBranches3066[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3067, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2209(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2768(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3066(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc900(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2208[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2209, x64Parser::tokenBranches2209}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2768, x64Parser::tokenBranches2768}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3066, x64Parser::tokenBranches3066}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2495(x64Operand& operand, int tokenPos) { operand.addressCoding = 181; } -x64Token x64Parser::tokenBranches2196[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2197}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2208}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2495, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc729(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc853(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2196(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches651[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc652, x64Parser::tokenBranches652 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc776, x64Parser::tokenBranches776 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc900, x64Parser::tokenBranches900 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc538(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches728[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc729, x64Parser::tokenBranches729}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc853, x64Parser::tokenBranches853}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2196, x64Parser::tokenBranches2196}, - {x64Token::EOT}}; -void x64Parser::TokenFunc491(x64Operand& operand, int tokenPos) { operand.addressCoding = 54; } -x64Token x64Parser::tokenBranches490[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc491, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches728}, - {x64Token::EOT}}; -void x64Parser::TokenFunc737(x64Operand& operand, int tokenPos) { operand.addressCoding = 73; } -x64Token x64Parser::tokenBranches736[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc737, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc861(x64Operand& operand, int tokenPos) { operand.addressCoding = 87; } -x64Token x64Parser::tokenBranches860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2181(x64Operand& operand, int tokenPos) { operand.addressCoding = 178; } -x64Token x64Parser::tokenBranches2180[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2181, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2740(x64Operand& operand, int tokenPos) { operand.addressCoding = 204; } -x64Token x64Parser::tokenBranches2739[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2740, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3038(x64Operand& operand, int tokenPos) { operand.addressCoding = 230; } -x64Token x64Parser::tokenBranches3037[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3038, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2180(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2739(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3037(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches537[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc538, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches651 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc644(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches2179[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2180, x64Parser::tokenBranches2180}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2739, x64Parser::tokenBranches2739}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3037, x64Parser::tokenBranches3037}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2472(x64Operand& operand, int tokenPos) { operand.addressCoding = 178; } -x64Token x64Parser::tokenBranches2178[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2179}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2472, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2178(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches643[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc644, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc768(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches2177[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2178, x64Parser::tokenBranches2178}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2190(x64Operand& operand, int tokenPos) { operand.addressCoding = 179; } -x64Token x64Parser::tokenBranches2189[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2190, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2749(x64Operand& operand, int tokenPos) { operand.addressCoding = 205; } -x64Token x64Parser::tokenBranches2748[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2749, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3047(x64Operand& operand, int tokenPos) { operand.addressCoding = 231; } -x64Token x64Parser::tokenBranches3046[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3047, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2189(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2748(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3046(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches767[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc768, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc892(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches2188[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2189, x64Parser::tokenBranches2189}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2748, x64Parser::tokenBranches2748}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3046, x64Parser::tokenBranches3046}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2479(x64Operand& operand, int tokenPos) { operand.addressCoding = 179; } -x64Token x64Parser::tokenBranches2176[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2177}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2188}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2479, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2237(x64Operand& operand, int tokenPos) { operand.addressCoding = 183; } -x64Token x64Parser::tokenBranches2236[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2237, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2649(x64Operand& operand, int tokenPos) { operand.addressCoding = 199; } -x64Token x64Parser::tokenBranches2648[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2649, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3027(x64Operand& operand, int tokenPos) { operand.addressCoding = 229; } -x64Token x64Parser::tokenBranches3026[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3027, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2236(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2648(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3026(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches891[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc892, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2235[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2236, x64Parser::tokenBranches2236}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2648, x64Parser::tokenBranches2648}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3026, x64Parser::tokenBranches3026}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2463(x64Operand& operand, int tokenPos) { operand.addressCoding = 183; } -x64Token x64Parser::tokenBranches2234[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2235}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2463, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc736(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc860(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2176(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2832(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 214; } -x64Token x64Parser::tokenBranches735[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2234}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc736, x64Parser::tokenBranches736}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc860, x64Parser::tokenBranches860}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2176, x64Parser::tokenBranches2176}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1043(x64Operand& operand, int tokenPos) { operand.addressCoding = 102; } -x64Token x64Parser::tokenBranches1042[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1043, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1052(x64Operand& operand, int tokenPos) { operand.addressCoding = 103; } -x64Token x64Parser::tokenBranches1051[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1052, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1061(x64Operand& operand, int tokenPos) { operand.addressCoding = 104; } -x64Token x64Parser::tokenBranches1060[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1061, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1042(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1051(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1060(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2831[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2832, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches1041[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1042, x64Parser::tokenBranches1042}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1051, x64Parser::tokenBranches1051}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1060, x64Parser::tokenBranches1060}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1034(x64Operand& operand, int tokenPos) { operand.addressCoding = 102; } -x64Token x64Parser::tokenBranches1033[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1034, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1041}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1171(x64Operand& operand, int tokenPos) { operand.addressCoding = 111; } -x64Token x64Parser::tokenBranches1170[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1171, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1180(x64Operand& operand, int tokenPos) { operand.addressCoding = 112; } -x64Token x64Parser::tokenBranches1179[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1180, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1189(x64Operand& operand, int tokenPos) { operand.addressCoding = 113; } -x64Token x64Parser::tokenBranches1188[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1189, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1170(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1179(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1188(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2299(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1169[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1170, x64Parser::tokenBranches1170}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1179, x64Parser::tokenBranches1179}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1188, x64Parser::tokenBranches1188}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1162(x64Operand& operand, int tokenPos) { operand.addressCoding = 111; } -x64Token x64Parser::tokenBranches1161[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1162, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1169}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1530(x64Operand& operand, int tokenPos) { operand.addressCoding = 136; } -x64Token x64Parser::tokenBranches1529[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1530, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1539(x64Operand& operand, int tokenPos) { operand.addressCoding = 137; } -x64Token x64Parser::tokenBranches1538[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1539, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1529(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1538(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2831(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1528[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1529, x64Parser::tokenBranches1529}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1538, x64Parser::tokenBranches1538}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1521(x64Operand& operand, int tokenPos) { operand.addressCoding = 136; } -x64Token x64Parser::tokenBranches1520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1521, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1528}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1033(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1161(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1520(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3129(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1032[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1033, x64Parser::tokenBranches1033}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1161, x64Parser::tokenBranches1161}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1520, x64Parser::tokenBranches1520}, - {x64Token::EOT}}; -void x64Parser::TokenFunc496(x64Operand& operand, int tokenPos) { operand.addressCoding = 55; } -x64Token x64Parser::tokenBranches495[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc496, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches735}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1032}, - {x64Token::EOT}}; -void x64Parser::TokenFunc637(x64Operand& operand, int tokenPos) { operand.addressCoding = 56; } -x64Token x64Parser::tokenBranches636[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc637, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc761(x64Operand& operand, int tokenPos) { operand.addressCoding = 77; } -x64Token x64Parser::tokenBranches760[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc761, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc885(x64Operand& operand, int tokenPos) { operand.addressCoding = 91; } -x64Token x64Parser::tokenBranches884[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc885, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2280(x64Operand& operand, int tokenPos) { operand.addressCoding = 187; } -x64Token x64Parser::tokenBranches2279[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2280, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2812(x64Operand& operand, int tokenPos) { operand.addressCoding = 212; } -x64Token x64Parser::tokenBranches2811[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2812, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3110(x64Operand& operand, int tokenPos) { operand.addressCoding = 238; } -x64Token x64Parser::tokenBranches3109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2279(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2811(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3109(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2298[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2299, x64Parser::tokenBranches2299 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2831, x64Parser::tokenBranches2831 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3129, x64Parser::tokenBranches3129 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2544(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2278[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2279, x64Parser::tokenBranches2279}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2811, x64Parser::tokenBranches2811}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3109, x64Parser::tokenBranches3109}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2528(x64Operand& operand, int tokenPos) { operand.addressCoding = 187; } -x64Token x64Parser::tokenBranches2277[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2278}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2528, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2277(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2297[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2298 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2544, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2297(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2276[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2277, x64Parser::tokenBranches2277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2289(x64Operand& operand, int tokenPos) { operand.addressCoding = 188; } -x64Token x64Parser::tokenBranches2288[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2289, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2821(x64Operand& operand, int tokenPos) { operand.addressCoding = 213; } -x64Token x64Parser::tokenBranches2820[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2821, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3119(x64Operand& operand, int tokenPos) { operand.addressCoding = 239; } -x64Token x64Parser::tokenBranches3118[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3119, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2288(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2820(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3118(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2296[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2297, x64Parser::tokenBranches2297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2309(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2287[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2288, x64Parser::tokenBranches2288}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2820, x64Parser::tokenBranches2820}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3118, x64Parser::tokenBranches3118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2535(x64Operand& operand, int tokenPos) { operand.addressCoding = 188; } -x64Token x64Parser::tokenBranches2275[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2276}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2287}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2535, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc636(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc760(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc884(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2275(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2308[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2309, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2841(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches635[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc636, x64Parser::tokenBranches636}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc760, x64Parser::tokenBranches760}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc884, x64Parser::tokenBranches884}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2275, x64Parser::tokenBranches2275}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1299(x64Operand& operand, int tokenPos) { operand.addressCoding = 120; } -x64Token x64Parser::tokenBranches1298[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1299, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1308(x64Operand& operand, int tokenPos) { operand.addressCoding = 121; } -x64Token x64Parser::tokenBranches1307[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1308, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1317(x64Operand& operand, int tokenPos) { operand.addressCoding = 122; } -x64Token x64Parser::tokenBranches1316[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1317, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1298(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1307(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1316(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2840[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2841, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3139(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches1297[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1298, x64Parser::tokenBranches1298}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1307, x64Parser::tokenBranches1307}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1316, x64Parser::tokenBranches1316}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1290(x64Operand& operand, int tokenPos) { operand.addressCoding = 120; } -x64Token x64Parser::tokenBranches1289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1290, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1427(x64Operand& operand, int tokenPos) { operand.addressCoding = 129; } -x64Token x64Parser::tokenBranches1426[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1427, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1436(x64Operand& operand, int tokenPos) { operand.addressCoding = 130; } -x64Token x64Parser::tokenBranches1435[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1436, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1445(x64Operand& operand, int tokenPos) { operand.addressCoding = 131; } -x64Token x64Parser::tokenBranches1444[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1445, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1426(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1435(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1444(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3138[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3139, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2308(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1425[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1426, x64Parser::tokenBranches1426}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1435, x64Parser::tokenBranches1435}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1444, x64Parser::tokenBranches1444}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1418(x64Operand& operand, int tokenPos) { operand.addressCoding = 129; } -x64Token x64Parser::tokenBranches1417[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1418, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1425}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1574(x64Operand& operand, int tokenPos) { operand.addressCoding = 139; } -x64Token x64Parser::tokenBranches1573[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1574, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1583(x64Operand& operand, int tokenPos) { operand.addressCoding = 140; } -x64Token x64Parser::tokenBranches1582[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1583, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1573(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1582(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2840(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1572[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1573, x64Parser::tokenBranches1573}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1582, x64Parser::tokenBranches1582}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1565(x64Operand& operand, int tokenPos) { operand.addressCoding = 139; } -x64Token x64Parser::tokenBranches1564[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1565, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1572}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1289(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1417(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1564(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3138(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1288[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1289, x64Parser::tokenBranches1289}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1417, x64Parser::tokenBranches1417}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1564, x64Parser::tokenBranches1564}, - {x64Token::EOT}}; -void x64Parser::TokenFunc501(x64Operand& operand, int tokenPos) { operand.addressCoding = 56; } -x64Token x64Parser::tokenBranches500[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc501, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches635}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1288}, - {x64Token::EOT}}; -void x64Parser::TokenFunc685(x64Operand& operand, int tokenPos) { operand.addressCoding = 62; } -x64Token x64Parser::tokenBranches684[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc685, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc809(x64Operand& operand, int tokenPos) { operand.addressCoding = 81; } -x64Token x64Parser::tokenBranches808[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc809, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc926(x64Operand& operand, int tokenPos) { operand.addressCoding = 94; } -x64Token x64Parser::tokenBranches925[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc926, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc684(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc808(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc925(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2307[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2308, x64Parser::tokenBranches2308 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2840, x64Parser::tokenBranches2840 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3138, x64Parser::tokenBranches3138 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2551(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2295[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2296 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2307 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc643(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc767(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc891(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2295(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches683[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc684, x64Parser::tokenBranches684}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc808, x64Parser::tokenBranches808}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc925, x64Parser::tokenBranches925}, - {x64Token::EOT}}; -void x64Parser::TokenFunc557(x64Operand& operand, int tokenPos) { operand.addressCoding = 62; } -x64Token x64Parser::tokenBranches556[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc557, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches683}, - {x64Token::EOT}}; -void x64Parser::TokenFunc676(x64Operand& operand, int tokenPos) { operand.addressCoding = 61; } -x64Token x64Parser::tokenBranches675[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc676, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc800(x64Operand& operand, int tokenPos) { operand.addressCoding = 80; } -x64Token x64Parser::tokenBranches799[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc800, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc933(x64Operand& operand, int tokenPos) { operand.addressCoding = 95; } -x64Token x64Parser::tokenBranches932[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc933, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2340(x64Operand& operand, int tokenPos) { operand.addressCoding = 191; } -x64Token x64Parser::tokenBranches2339[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2340, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2872(x64Operand& operand, int tokenPos) { operand.addressCoding = 217; } -x64Token x64Parser::tokenBranches2871[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2872, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3170(x64Operand& operand, int tokenPos) { operand.addressCoding = 242; } -x64Token x64Parser::tokenBranches3169[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3170, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2339(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2871(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3169(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches536[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches537 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc643, x64Parser::tokenBranches643 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc767, x64Parser::tokenBranches767 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc891, x64Parser::tokenBranches891 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2295, x64Parser::tokenBranches2295 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1625(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1624[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1625, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1634(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches1633[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1634, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1643(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches1642[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1643, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1624(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1633(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1642(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2338[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2339, x64Parser::tokenBranches2339}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2871, x64Parser::tokenBranches2871}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3169, x64Parser::tokenBranches3169}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2576(x64Operand& operand, int tokenPos) { operand.addressCoding = 191; } -x64Token x64Parser::tokenBranches2337[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2338}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2576, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2337(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1623[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1624, x64Parser::tokenBranches1624 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1633, x64Parser::tokenBranches1633 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1642, x64Parser::tokenBranches1642 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1616(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches2336[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2337, x64Parser::tokenBranches2337}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2349(x64Operand& operand, int tokenPos) { operand.addressCoding = 192; } -x64Token x64Parser::tokenBranches2348[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2349, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2881(x64Operand& operand, int tokenPos) { operand.addressCoding = 218; } -x64Token x64Parser::tokenBranches2880[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2881, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3179(x64Operand& operand, int tokenPos) { operand.addressCoding = 243; } -x64Token x64Parser::tokenBranches3178[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3179, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2348(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2880(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3178(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1615[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1616, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1623 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1753(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches2347[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2348, x64Parser::tokenBranches2348}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2880, x64Parser::tokenBranches2880}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3178, x64Parser::tokenBranches3178}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2583(x64Operand& operand, int tokenPos) { operand.addressCoding = 192; } -x64Token x64Parser::tokenBranches2335[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2336}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2347}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2583, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc675(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc799(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc932(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2335(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1752[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1753, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1762(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches555[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches556}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc675, x64Parser::tokenBranches675}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc799, x64Parser::tokenBranches799}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc932, x64Parser::tokenBranches932}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2335, x64Parser::tokenBranches2335}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1693(x64Operand& operand, int tokenPos) { operand.addressCoding = 144; } -x64Token x64Parser::tokenBranches1692[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1693, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1702(x64Operand& operand, int tokenPos) { operand.addressCoding = 145; } -x64Token x64Parser::tokenBranches1701[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1702, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1711(x64Operand& operand, int tokenPos) { operand.addressCoding = 146; } -x64Token x64Parser::tokenBranches1710[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1711, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1692(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1701(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1710(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1761[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1762, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1771(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1691[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1692, x64Parser::tokenBranches1692}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1701, x64Parser::tokenBranches1701}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1710, x64Parser::tokenBranches1710}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1684(x64Operand& operand, int tokenPos) { operand.addressCoding = 144; } -x64Token x64Parser::tokenBranches1683[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1684, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1691}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1821(x64Operand& operand, int tokenPos) { operand.addressCoding = 153; } -x64Token x64Parser::tokenBranches1820[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1821, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1830(x64Operand& operand, int tokenPos) { operand.addressCoding = 154; } -x64Token x64Parser::tokenBranches1829[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1830, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1839(x64Operand& operand, int tokenPos) { operand.addressCoding = 155; } -x64Token x64Parser::tokenBranches1838[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1839, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1820(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1829(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1838(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1770[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1771, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1752(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1819[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1820, x64Parser::tokenBranches1820}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1829, x64Parser::tokenBranches1829}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1838, x64Parser::tokenBranches1838}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1812(x64Operand& operand, int tokenPos) { operand.addressCoding = 153; } -x64Token x64Parser::tokenBranches1811[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1812, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1819}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2011(x64Operand& operand, int tokenPos) { operand.addressCoding = 165; } -x64Token x64Parser::tokenBranches2010[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2011, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2020(x64Operand& operand, int tokenPos) { operand.addressCoding = 166; } -x64Token x64Parser::tokenBranches2019[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2020, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2040(x64Operand& operand, int tokenPos) { operand.addressCoding = 167; } -x64Token x64Parser::tokenBranches2039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2051(x64Operand& operand, int tokenPos) { operand.addressCoding = 168; } -x64Token x64Parser::tokenBranches2050[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2051, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2039(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2050(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1761(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2038[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2039, x64Parser::tokenBranches2039}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2050, x64Parser::tokenBranches2050}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2029(x64Operand& operand, int tokenPos) { operand.addressCoding = 167; } -x64Token x64Parser::tokenBranches2028[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2029, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2038}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2010(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2019(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1770(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2009[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2028}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2010, x64Parser::tokenBranches2010}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2019, x64Parser::tokenBranches2019}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2002(x64Operand& operand, int tokenPos) { operand.addressCoding = 165; } -x64Token x64Parser::tokenBranches2001[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2002, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2009}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1683(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1811(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2001(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1751[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1752, x64Parser::tokenBranches1752 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1761, x64Parser::tokenBranches1761 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1770, x64Parser::tokenBranches1770 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1744(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1682[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1683, x64Parser::tokenBranches1683}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1811, x64Parser::tokenBranches1811}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2001, x64Parser::tokenBranches2001}, - {x64Token::EOT}}; -void x64Parser::TokenFunc550(x64Operand& operand, int tokenPos) { operand.addressCoding = 61; } -x64Token x64Parser::tokenBranches549[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc550, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches555}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1682}, - {x64Token::EOT}}; -void x64Parser::TokenFunc575(x64Operand& operand, int tokenPos) { operand.addressCoding = 66; } -x64Token x64Parser::tokenBranches574[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc575, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3277(x64Operand& operand, int tokenPos) { operand.addressCoding = 248; } -x64Token x64Parser::tokenBranches3276[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3277, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3368(x64Operand& operand, int tokenPos) { operand.addressCoding = 264; } -x64Token x64Parser::tokenBranches3367[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3368, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3460(x64Operand& operand, int tokenPos) { operand.addressCoding = 278; } -x64Token x64Parser::tokenBranches3459[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3460, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4569(x64Operand& operand, int tokenPos) { operand.addressCoding = 379; } -x64Token x64Parser::tokenBranches4568[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4569, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4945(x64Operand& operand, int tokenPos) { operand.addressCoding = 403; } -x64Token x64Parser::tokenBranches4944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5157(x64Operand& operand, int tokenPos) { operand.addressCoding = 427; } -x64Token x64Parser::tokenBranches5156[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5157, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4568(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4944(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5156(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1743[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1744, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1751 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1899(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches4567[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4568, x64Parser::tokenBranches4568}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4944, x64Parser::tokenBranches4944}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5156, x64Parser::tokenBranches5156}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4755(x64Operand& operand, int tokenPos) { operand.addressCoding = 379; } -x64Token x64Parser::tokenBranches4566[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4567}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4755, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4566(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1898[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1899, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1908(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches4565[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4566, x64Parser::tokenBranches4566}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4578(x64Operand& operand, int tokenPos) { operand.addressCoding = 380; } -x64Token x64Parser::tokenBranches4577[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4578, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4954(x64Operand& operand, int tokenPos) { operand.addressCoding = 404; } -x64Token x64Parser::tokenBranches4953[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4954, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5166(x64Operand& operand, int tokenPos) { operand.addressCoding = 428; } -x64Token x64Parser::tokenBranches5165[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5166, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4577(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4953(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5165(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1907[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1908, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1928(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches4576[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4577, x64Parser::tokenBranches4577}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4953, x64Parser::tokenBranches4953}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5165, x64Parser::tokenBranches5165}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4762(x64Operand& operand, int tokenPos) { operand.addressCoding = 380; } -x64Token x64Parser::tokenBranches4564[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4565}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4576}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4762, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3276(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3367(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3459(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4564(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1927[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1928, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1939(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches3275[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3276, x64Parser::tokenBranches3276}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3367, x64Parser::tokenBranches3367}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3459, x64Parser::tokenBranches3459}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4564, x64Parser::tokenBranches4564}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3196(x64Operand& operand, int tokenPos) { operand.addressCoding = 248; } -x64Token x64Parser::tokenBranches3195[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3196, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3275}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3337(x64Operand& operand, int tokenPos) { operand.addressCoding = 256; } -x64Token x64Parser::tokenBranches3336[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3337, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3429(x64Operand& operand, int tokenPos) { operand.addressCoding = 273; } -x64Token x64Parser::tokenBranches3428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3521(x64Operand& operand, int tokenPos) { operand.addressCoding = 287; } -x64Token x64Parser::tokenBranches3520[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3521, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3336(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3428(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3520(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1938[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1939, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1927(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3335[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3336, x64Parser::tokenBranches3336}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3428, x64Parser::tokenBranches3428}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3520, x64Parser::tokenBranches3520}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3236(x64Operand& operand, int tokenPos) { operand.addressCoding = 256; } -x64Token x64Parser::tokenBranches3235[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3236, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3335}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3375(x64Operand& operand, int tokenPos) { operand.addressCoding = 265; } -x64Token x64Parser::tokenBranches3374[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3375, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3467(x64Operand& operand, int tokenPos) { operand.addressCoding = 279; } -x64Token x64Parser::tokenBranches3466[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3467, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4589(x64Operand& operand, int tokenPos) { operand.addressCoding = 381; } -x64Token x64Parser::tokenBranches4588[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4589, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4965(x64Operand& operand, int tokenPos) { operand.addressCoding = 405; } -x64Token x64Parser::tokenBranches4964[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4965, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5177(x64Operand& operand, int tokenPos) { operand.addressCoding = 429; } -x64Token x64Parser::tokenBranches5176[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5177, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4588(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4964(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5176(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1938(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4587[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4588, x64Parser::tokenBranches4588}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4964, x64Parser::tokenBranches4964}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5176, x64Parser::tokenBranches5176}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4771(x64Operand& operand, int tokenPos) { operand.addressCoding = 381; } -x64Token x64Parser::tokenBranches4586[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4587}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4771, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4586(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1926[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1927, x64Parser::tokenBranches1927 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1938, x64Parser::tokenBranches1938 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1917(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1916[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1917, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1926 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1898(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1907(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4585[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4586, x64Parser::tokenBranches4586}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4598(x64Operand& operand, int tokenPos) { operand.addressCoding = 382; } -x64Token x64Parser::tokenBranches4597[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4598, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4974(x64Operand& operand, int tokenPos) { operand.addressCoding = 406; } -x64Token x64Parser::tokenBranches4973[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4974, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5186(x64Operand& operand, int tokenPos) { operand.addressCoding = 430; } -x64Token x64Parser::tokenBranches5185[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5186, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4597(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4973(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5185(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1897[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1916 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1898, x64Parser::tokenBranches1898 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1907, x64Parser::tokenBranches1907 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1890(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1889[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1890, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1897 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1615(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1743(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1889(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4596[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4597, x64Parser::tokenBranches4597}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4973, x64Parser::tokenBranches4973}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5185, x64Parser::tokenBranches5185}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4778(x64Operand& operand, int tokenPos) { operand.addressCoding = 382; } -x64Token x64Parser::tokenBranches4584[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4585}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4596}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3374(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3466(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4584(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1614[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1615, x64Parser::tokenBranches1615 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1743, x64Parser::tokenBranches1743 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1889, x64Parser::tokenBranches1889 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc526(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches3234[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3235}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3374, x64Parser::tokenBranches3374}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3466, x64Parser::tokenBranches3466}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4584, x64Parser::tokenBranches4584}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3283(x64Operand& operand, int tokenPos) { operand.addressCoding = 249; } -x64Token x64Parser::tokenBranches3282[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3283, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3572(x64Operand& operand, int tokenPos) { operand.addressCoding = 289; } -x64Token x64Parser::tokenBranches3571[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3581(x64Operand& operand, int tokenPos) { operand.addressCoding = 290; } -x64Token x64Parser::tokenBranches3580[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3581, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3590(x64Operand& operand, int tokenPos) { operand.addressCoding = 291; } -x64Token x64Parser::tokenBranches3589[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3590, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3571(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3580(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3589(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches525[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc526, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches536 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1614 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc565(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 64; } -x64Token x64Parser::tokenBranches3570[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3571, x64Parser::tokenBranches3571}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3580, x64Parser::tokenBranches3580}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3589, x64Parser::tokenBranches3589}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3563(x64Operand& operand, int tokenPos) { operand.addressCoding = 289; } -x64Token x64Parser::tokenBranches3562[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3563, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3570}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3632(x64Operand& operand, int tokenPos) { operand.addressCoding = 295; } -x64Token x64Parser::tokenBranches3631[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3632, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3641(x64Operand& operand, int tokenPos) { operand.addressCoding = 296; } -x64Token x64Parser::tokenBranches3640[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3641, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3650(x64Operand& operand, int tokenPos) { operand.addressCoding = 297; } -x64Token x64Parser::tokenBranches3649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3650, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3631(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3640(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3649(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches564[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc565, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1231(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches3630[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3631, x64Parser::tokenBranches3631}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3640, x64Parser::tokenBranches3640}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3649, x64Parser::tokenBranches3649}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3623(x64Operand& operand, int tokenPos) { operand.addressCoding = 295; } -x64Token x64Parser::tokenBranches3622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3623, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3630}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3678(x64Operand& operand, int tokenPos) { operand.addressCoding = 301; } -x64Token x64Parser::tokenBranches3677[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3678, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3677(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1230[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1231, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1240(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 118; } -x64Token x64Parser::tokenBranches3676[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3677, x64Parser::tokenBranches3677}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3669(x64Operand& operand, int tokenPos) { operand.addressCoding = 300; } -x64Token x64Parser::tokenBranches3668[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3669, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3676}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3706(x64Operand& operand, int tokenPos) { operand.addressCoding = 305; } -x64Token x64Parser::tokenBranches3705[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3706, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3705(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1239[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1240, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1249(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 119; } -x64Token x64Parser::tokenBranches3704[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3705, x64Parser::tokenBranches3705}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3697(x64Operand& operand, int tokenPos) { operand.addressCoding = 304; } -x64Token x64Parser::tokenBranches3696[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3697, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3704}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3562(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3622(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3668(x64Operand& operand, int tokenPos) -{ - operand.values[13] = new Coding[2]; - CleanupValues.push_back(operand.values[13]); - operand.values[13]->type = Coding::number; - operand.values[13]->val = operands.size(); - operand.values[13]->bits = 0; - operand.values[13]->field = 0; - operand.values[13]->unary = 0; - operand.values[13]->binary = 0; - operand.values[13][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3696(x64Operand& operand, int tokenPos) -{ - operand.values[14] = new Coding[2]; - CleanupValues.push_back(operand.values[14]); - operand.values[14]->type = Coding::number; - operand.values[14]->val = operands.size(); - operand.values[14]->bits = 0; - operand.values[14]->field = 0; - operand.values[14]->unary = 0; - operand.values[14]->binary = 0; - operand.values[14][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1248[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1249, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1230(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3561[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3562, x64Parser::tokenBranches3562}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3622, x64Parser::tokenBranches3622}, - {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3668, x64Parser::tokenBranches3668}, - {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3696, x64Parser::tokenBranches3696}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3201(x64Operand& operand, int tokenPos) { operand.addressCoding = 249; } -void x64Parser::TokenFunc3282(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1239(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3200[] = { - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3201, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3234}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3282, x64Parser::tokenBranches3282}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3561}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3290(x64Operand& operand, int tokenPos) { operand.addressCoding = 250; } -x64Token x64Parser::tokenBranches3289[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3290, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3382(x64Operand& operand, int tokenPos) { operand.addressCoding = 266; } -x64Token x64Parser::tokenBranches3381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3382, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3474(x64Operand& operand, int tokenPos) { operand.addressCoding = 280; } -x64Token x64Parser::tokenBranches3473[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3474, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4481(x64Operand& operand, int tokenPos) { operand.addressCoding = 369; } -x64Token x64Parser::tokenBranches4480[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4481, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4857(x64Operand& operand, int tokenPos) { operand.addressCoding = 393; } -x64Token x64Parser::tokenBranches4856[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4857, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5069(x64Operand& operand, int tokenPos) { operand.addressCoding = 417; } -x64Token x64Parser::tokenBranches5068[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5069, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4480(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4856(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5068(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1248(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4479[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4480, x64Parser::tokenBranches4480}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4856, x64Parser::tokenBranches4856}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5068, x64Parser::tokenBranches5068}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4687(x64Operand& operand, int tokenPos) { operand.addressCoding = 369; } -x64Token x64Parser::tokenBranches4478[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4479}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4687, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4549(x64Operand& operand, int tokenPos) { operand.addressCoding = 377; } -x64Token x64Parser::tokenBranches4548[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4549, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4925(x64Operand& operand, int tokenPos) { operand.addressCoding = 401; } -x64Token x64Parser::tokenBranches4924[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4925, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5137(x64Operand& operand, int tokenPos) { operand.addressCoding = 425; } -x64Token x64Parser::tokenBranches5136[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5137, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4548(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4924(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5136(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1229[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1230, x64Parser::tokenBranches1230 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1239, x64Parser::tokenBranches1239 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1248, x64Parser::tokenBranches1248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1222(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 117; } -x64Token x64Parser::tokenBranches4547[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4548, x64Parser::tokenBranches4548}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4924, x64Parser::tokenBranches4924}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5136, x64Parser::tokenBranches5136}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4739(x64Operand& operand, int tokenPos) { operand.addressCoding = 377; } -x64Token x64Parser::tokenBranches4546[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4547}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4739, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4546(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1221[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1222, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1229 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1359(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 126; } -x64Token x64Parser::tokenBranches4545[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4546, x64Parser::tokenBranches4546}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4558(x64Operand& operand, int tokenPos) { operand.addressCoding = 378; } -x64Token x64Parser::tokenBranches4557[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4558, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4934(x64Operand& operand, int tokenPos) { operand.addressCoding = 402; } -x64Token x64Parser::tokenBranches4933[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4934, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5146(x64Operand& operand, int tokenPos) { operand.addressCoding = 426; } -x64Token x64Parser::tokenBranches5145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4557(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4933(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5145(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1358[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1359, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1368(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 127; } -x64Token x64Parser::tokenBranches4556[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4557, x64Parser::tokenBranches4557}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4933, x64Parser::tokenBranches4933}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5145, x64Parser::tokenBranches5145}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4746(x64Operand& operand, int tokenPos) { operand.addressCoding = 378; } -x64Token x64Parser::tokenBranches4544[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4545}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4556}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4746, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3289(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3381(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3473(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4544(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches1367[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1368, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1377(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 128; } -x64Token x64Parser::tokenBranches3288[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4478}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3289, x64Parser::tokenBranches3289}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3381, x64Parser::tokenBranches3381}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3473, x64Parser::tokenBranches3473}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4544, x64Parser::tokenBranches4544}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3816(x64Operand& operand, int tokenPos) { operand.addressCoding = 312; } -x64Token x64Parser::tokenBranches3815[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3816, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3825(x64Operand& operand, int tokenPos) { operand.addressCoding = 313; } -x64Token x64Parser::tokenBranches3824[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3825, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3834(x64Operand& operand, int tokenPos) { operand.addressCoding = 314; } -x64Token x64Parser::tokenBranches3833[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3834, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3815(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3824(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3833(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1376[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1377, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1358(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3814[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3815, x64Parser::tokenBranches3815}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3824, x64Parser::tokenBranches3824}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3833, x64Parser::tokenBranches3833}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3807(x64Operand& operand, int tokenPos) { operand.addressCoding = 312; } -x64Token x64Parser::tokenBranches3806[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3807, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3814}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3944(x64Operand& operand, int tokenPos) { operand.addressCoding = 321; } -x64Token x64Parser::tokenBranches3943[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3944, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3953(x64Operand& operand, int tokenPos) { operand.addressCoding = 322; } -x64Token x64Parser::tokenBranches3952[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3953, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3962(x64Operand& operand, int tokenPos) { operand.addressCoding = 323; } -x64Token x64Parser::tokenBranches3961[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3962, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3943(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3952(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3961(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1367(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3942[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3943, x64Parser::tokenBranches3943}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3952, x64Parser::tokenBranches3952}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3961, x64Parser::tokenBranches3961}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3935(x64Operand& operand, int tokenPos) { operand.addressCoding = 321; } -x64Token x64Parser::tokenBranches3934[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3935, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3942}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4246(x64Operand& operand, int tokenPos) { operand.addressCoding = 345; } -x64Token x64Parser::tokenBranches4245[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4245(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1376(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4244[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4245, x64Parser::tokenBranches4245}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4237(x64Operand& operand, int tokenPos) { operand.addressCoding = 344; } -x64Token x64Parser::tokenBranches4236[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4237, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4244}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3806(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3934(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4236(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1357[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1358, x64Parser::tokenBranches1358 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1367, x64Parser::tokenBranches1367 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1376, x64Parser::tokenBranches1376 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1350(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 126; +} +x64Token x64Parser::tokenBranches1349[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1350, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1357 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1221(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1349(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3805[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3806, x64Parser::tokenBranches3806}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3934, x64Parser::tokenBranches3934}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4236, x64Parser::tokenBranches4236}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3206(x64Operand& operand, int tokenPos) { operand.addressCoding = 250; } -x64Token x64Parser::tokenBranches3205[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3206, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3288}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3805}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3321(x64Operand& operand, int tokenPos) { operand.addressCoding = 251; } -x64Token x64Parser::tokenBranches3320[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3321, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3413(x64Operand& operand, int tokenPos) { operand.addressCoding = 271; } -x64Token x64Parser::tokenBranches3412[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3413, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3505(x64Operand& operand, int tokenPos) { operand.addressCoding = 285; } -x64Token x64Parser::tokenBranches3504[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3505, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4490(x64Operand& operand, int tokenPos) { operand.addressCoding = 370; } -x64Token x64Parser::tokenBranches4489[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4490, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4866(x64Operand& operand, int tokenPos) { operand.addressCoding = 394; } -x64Token x64Parser::tokenBranches4865[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4866, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5078(x64Operand& operand, int tokenPos) { operand.addressCoding = 418; } -x64Token x64Parser::tokenBranches5077[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5078, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4489(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4865(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5077(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1220[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1221, x64Parser::tokenBranches1221 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1349, x64Parser::tokenBranches1349 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches1219[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1220 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3748(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches4488[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4489, x64Parser::tokenBranches4489}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4865, x64Parser::tokenBranches4865}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5077, x64Parser::tokenBranches5077}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4694(x64Operand& operand, int tokenPos) { operand.addressCoding = 370; } -x64Token x64Parser::tokenBranches4487[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4488}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4694, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4641(x64Operand& operand, int tokenPos) { operand.addressCoding = 387; } -x64Token x64Parser::tokenBranches4640[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4641, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5017(x64Operand& operand, int tokenPos) { operand.addressCoding = 411; } -x64Token x64Parser::tokenBranches5016[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5017, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5229(x64Operand& operand, int tokenPos) { operand.addressCoding = 435; } -x64Token x64Parser::tokenBranches5228[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5229, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4640(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5016(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5228(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3747[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3748, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3757(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 310; } -x64Token x64Parser::tokenBranches4639[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4640, x64Parser::tokenBranches4640}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5016, x64Parser::tokenBranches5016}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5228, x64Parser::tokenBranches5228}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4811(x64Operand& operand, int tokenPos) { operand.addressCoding = 387; } -x64Token x64Parser::tokenBranches4638[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4639}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4811, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4638(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3756[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3757, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3766(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 311; } -x64Token x64Parser::tokenBranches4637[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4638, x64Parser::tokenBranches4638}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4650(x64Operand& operand, int tokenPos) { operand.addressCoding = 388; } -x64Token x64Parser::tokenBranches4649[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4650, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5026(x64Operand& operand, int tokenPos) { operand.addressCoding = 412; } -x64Token x64Parser::tokenBranches5025[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5026, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5238(x64Operand& operand, int tokenPos) { operand.addressCoding = 436; } -x64Token x64Parser::tokenBranches5237[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5238, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4649(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5025(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5237(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3765[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3766, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3747(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4648[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4649, x64Parser::tokenBranches4649}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5025, x64Parser::tokenBranches5025}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5237, x64Parser::tokenBranches5237}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4818(x64Operand& operand, int tokenPos) { operand.addressCoding = 388; } -x64Token x64Parser::tokenBranches4636[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4637}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4648}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4818, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3320(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3412(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3504(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4636(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc3756(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3319[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4487}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3320, x64Parser::tokenBranches3320}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3412, x64Parser::tokenBranches3412}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3504, x64Parser::tokenBranches3504}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4636, x64Parser::tokenBranches4636}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4072(x64Operand& operand, int tokenPos) { operand.addressCoding = 330; } -x64Token x64Parser::tokenBranches4071[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4072, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4081(x64Operand& operand, int tokenPos) { operand.addressCoding = 331; } -x64Token x64Parser::tokenBranches4080[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4081, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4090(x64Operand& operand, int tokenPos) { operand.addressCoding = 332; } -x64Token x64Parser::tokenBranches4089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4071(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4080(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4089(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3765(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4070[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4071, x64Parser::tokenBranches4071}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4080, x64Parser::tokenBranches4080}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4089, x64Parser::tokenBranches4089}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4063(x64Operand& operand, int tokenPos) { operand.addressCoding = 330; } -x64Token x64Parser::tokenBranches4062[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4063, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4070}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4200(x64Operand& operand, int tokenPos) { operand.addressCoding = 339; } -x64Token x64Parser::tokenBranches4199[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4200, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4209(x64Operand& operand, int tokenPos) { operand.addressCoding = 340; } -x64Token x64Parser::tokenBranches4208[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4209, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4218(x64Operand& operand, int tokenPos) { operand.addressCoding = 341; } -x64Token x64Parser::tokenBranches4217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4199(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4208(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4217(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3746[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3747, x64Parser::tokenBranches3747 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3756, x64Parser::tokenBranches3756 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3765, x64Parser::tokenBranches3765 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3739(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 309; } -x64Token x64Parser::tokenBranches4198[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4199, x64Parser::tokenBranches4199}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4208, x64Parser::tokenBranches4208}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4217, x64Parser::tokenBranches4217}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4191(x64Operand& operand, int tokenPos) { operand.addressCoding = 339; } -x64Token x64Parser::tokenBranches4190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4191, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4198}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4274(x64Operand& operand, int tokenPos) { operand.addressCoding = 349; } -x64Token x64Parser::tokenBranches4273[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4274, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4273(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3738[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3739, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3746 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3876(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 318; } -x64Token x64Parser::tokenBranches4272[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4273, x64Parser::tokenBranches4273}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4265(x64Operand& operand, int tokenPos) { operand.addressCoding = 348; } -x64Token x64Parser::tokenBranches4264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4265, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4272}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4062(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4190(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4264(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3875[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3876, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3885(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 319; } -x64Token x64Parser::tokenBranches4061[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4062, x64Parser::tokenBranches4062}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4190, x64Parser::tokenBranches4190}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4264, x64Parser::tokenBranches4264}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3211(x64Operand& operand, int tokenPos) { operand.addressCoding = 251; } -x64Token x64Parser::tokenBranches3210[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3211, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3319}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4061}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3346(x64Operand& operand, int tokenPos) { operand.addressCoding = 257; } -x64Token x64Parser::tokenBranches3345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3438(x64Operand& operand, int tokenPos) { operand.addressCoding = 274; } -x64Token x64Parser::tokenBranches3437[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3438, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3530(x64Operand& operand, int tokenPos) { operand.addressCoding = 288; } -x64Token x64Parser::tokenBranches3529[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3530, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3345(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3437(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3529(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3884[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3885, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3894(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 320; } -x64Token x64Parser::tokenBranches3344[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3345, x64Parser::tokenBranches3345}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3437, x64Parser::tokenBranches3437}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3529, x64Parser::tokenBranches3529}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3243(x64Operand& operand, int tokenPos) { operand.addressCoding = 257; } -x64Token x64Parser::tokenBranches3242[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3243, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3344}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3328(x64Operand& operand, int tokenPos) { operand.addressCoding = 255; } -x64Token x64Parser::tokenBranches3327[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3328, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3420(x64Operand& operand, int tokenPos) { operand.addressCoding = 272; } -x64Token x64Parser::tokenBranches3419[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3420, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3512(x64Operand& operand, int tokenPos) { operand.addressCoding = 286; } -x64Token x64Parser::tokenBranches3511[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3512, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4661(x64Operand& operand, int tokenPos) { operand.addressCoding = 389; } -x64Token x64Parser::tokenBranches4660[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4661, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5037(x64Operand& operand, int tokenPos) { operand.addressCoding = 413; } -x64Token x64Parser::tokenBranches5036[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5037, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5249(x64Operand& operand, int tokenPos) { operand.addressCoding = 437; } -x64Token x64Parser::tokenBranches5248[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5249, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4660(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5036(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5248(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3893[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3894, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3875(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4659[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4660, x64Parser::tokenBranches4660}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5036, x64Parser::tokenBranches5036}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5248, x64Parser::tokenBranches5248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4827(x64Operand& operand, int tokenPos) { operand.addressCoding = 389; } -x64Token x64Parser::tokenBranches4658[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4659}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4827, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4658(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3884(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4657[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4658, x64Parser::tokenBranches4658}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4670(x64Operand& operand, int tokenPos) { operand.addressCoding = 390; } -x64Token x64Parser::tokenBranches4669[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4670, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5046(x64Operand& operand, int tokenPos) { operand.addressCoding = 414; } -x64Token x64Parser::tokenBranches5045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5046, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5258(x64Operand& operand, int tokenPos) { operand.addressCoding = 438; } -x64Token x64Parser::tokenBranches5257[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5258, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4669(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5045(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5257(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3893(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4668[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4669, x64Parser::tokenBranches4669}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5045, x64Parser::tokenBranches5045}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5257, x64Parser::tokenBranches5257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4834(x64Operand& operand, int tokenPos) { operand.addressCoding = 390; } -x64Token x64Parser::tokenBranches4656[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4657}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4668}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4834, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3327(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3419(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3511(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4656(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches3874[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3875, x64Parser::tokenBranches3875 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3884, x64Parser::tokenBranches3884 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3893, x64Parser::tokenBranches3893 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3867(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 318; +} +x64Token x64Parser::tokenBranches3866[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3867, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3874 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3738(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3866(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3241[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3242}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3327, x64Parser::tokenBranches3327}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3419, x64Parser::tokenBranches3419}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3511, x64Parser::tokenBranches3511}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4656, x64Parser::tokenBranches4656}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4316(x64Operand& operand, int tokenPos) { operand.addressCoding = 350; } -x64Token x64Parser::tokenBranches4315[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4316, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4325(x64Operand& operand, int tokenPos) { operand.addressCoding = 351; } -x64Token x64Parser::tokenBranches4324[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4325, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4334(x64Operand& operand, int tokenPos) { operand.addressCoding = 352; } -x64Token x64Parser::tokenBranches4333[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4334, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4315(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4324(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4333(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3737[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3738, x64Parser::tokenBranches3738 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3866, x64Parser::tokenBranches3866 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3736[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3737 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4004(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches4314[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4315, x64Parser::tokenBranches4315}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4324, x64Parser::tokenBranches4324}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4333, x64Parser::tokenBranches4333}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4307(x64Operand& operand, int tokenPos) { operand.addressCoding = 350; } -x64Token x64Parser::tokenBranches4306[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4307, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4314}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4376(x64Operand& operand, int tokenPos) { operand.addressCoding = 356; } -x64Token x64Parser::tokenBranches4375[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4376, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4385(x64Operand& operand, int tokenPos) { operand.addressCoding = 357; } -x64Token x64Parser::tokenBranches4384[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4385, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4394(x64Operand& operand, int tokenPos) { operand.addressCoding = 358; } -x64Token x64Parser::tokenBranches4393[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4394, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4375(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4384(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4393(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4003[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4004, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4013(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 328; } -x64Token x64Parser::tokenBranches4374[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4375, x64Parser::tokenBranches4375}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4384, x64Parser::tokenBranches4384}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4393, x64Parser::tokenBranches4393}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4367(x64Operand& operand, int tokenPos) { operand.addressCoding = 356; } -x64Token x64Parser::tokenBranches4366[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4367, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4374}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4438(x64Operand& operand, int tokenPos) { operand.addressCoding = 364; } -x64Token x64Parser::tokenBranches4437[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4438, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4458(x64Operand& operand, int tokenPos) { operand.addressCoding = 366; } -x64Token x64Parser::tokenBranches4457[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4458, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4457(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4012[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4013, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4022(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 329; } -x64Token x64Parser::tokenBranches4456[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4457, x64Parser::tokenBranches4457}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4447(x64Operand& operand, int tokenPos) { operand.addressCoding = 365; } -x64Token x64Parser::tokenBranches4446[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4447, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4456}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4437(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4021[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4022, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4003(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4436[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4446}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4437, x64Parser::tokenBranches4437}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4429(x64Operand& operand, int tokenPos) { operand.addressCoding = 363; } -x64Token x64Parser::tokenBranches4428[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4429, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4436}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4306(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4366(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4428(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4012(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4305[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4306, x64Parser::tokenBranches4306}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4366, x64Parser::tokenBranches4366}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4428, x64Parser::tokenBranches4428}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3229(x64Operand& operand, int tokenPos) { operand.addressCoding = 255; } -x64Token x64Parser::tokenBranches3228[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3229, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3241}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3256(x64Operand& operand, int tokenPos) { operand.addressCoding = 260; } -x64Token x64Parser::tokenBranches3255[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3256, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc18(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc88(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc549(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc574(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3228(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc3255(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4021(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches17[] = { - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches61}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches68}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches490}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches495}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches500}, - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3195}, - {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3200}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3205}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3210}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc18, x64Parser::tokenBranches18}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc88, x64Parser::tokenBranches88}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc549, x64Parser::tokenBranches549}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc574, x64Parser::tokenBranches574}, - {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3228, x64Parser::tokenBranches3228}, - {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3255, x64Parser::tokenBranches3255}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches16[] = {{x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches17}, - {x64Token::EOT}}; -void x64Parser::TokenFunc184(x64Operand& operand, int tokenPos) { operand.addressCoding = 19; } -x64Token x64Parser::tokenBranches183[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc184, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc330(x64Operand& operand, int tokenPos) { operand.addressCoding = 34; } -x64Token x64Parser::tokenBranches329[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc330, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc183(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc329(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4002[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4003, x64Parser::tokenBranches4003 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4012, x64Parser::tokenBranches4012 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4021, x64Parser::tokenBranches4021 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3995(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 327; } -x64Token x64Parser::tokenBranches182[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc183, x64Parser::tokenBranches183}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc329, x64Parser::tokenBranches329}, - {x64Token::EOT}}; -void x64Parser::TokenFunc24(x64Operand& operand, int tokenPos) { operand.addressCoding = 4; } -x64Token x64Parser::tokenBranches23[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc24, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches182}, - {x64Token::EOT}}; -void x64Parser::TokenFunc130(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc130, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc276(x64Operand& operand, int tokenPos) { operand.addressCoding = 28; } -x64Token x64Parser::tokenBranches275[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc276, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc422(x64Operand& operand, int tokenPos) { operand.addressCoding = 43; } -x64Token x64Parser::tokenBranches421[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc422, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc23(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc129(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc275(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc421(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3994[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3995, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4002 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4132(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 336; } -x64Token x64Parser::tokenBranches22[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc23, x64Parser::tokenBranches23}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc129, x64Parser::tokenBranches129}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc275, x64Parser::tokenBranches275}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc421, x64Parser::tokenBranches421}, - {x64Token::EOT}}; -void x64Parser::TokenFunc92(x64Operand& operand, int tokenPos) { operand.addressCoding = 13; } -x64Token x64Parser::tokenBranches21[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches22}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc92, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc191(x64Operand& operand, int tokenPos) { operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc191, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc337(x64Operand& operand, int tokenPos) { operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches336[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc337, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc190(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc336(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4131[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4132, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4141(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 337; } -x64Token x64Parser::tokenBranches189[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc190, x64Parser::tokenBranches190}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc336, x64Parser::tokenBranches336}, - {x64Token::EOT}}; -void x64Parser::TokenFunc29(x64Operand& operand, int tokenPos) { operand.addressCoding = 5; } -x64Token x64Parser::tokenBranches28[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc29, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches189}, - {x64Token::EOT}}; -void x64Parser::TokenFunc156(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches155[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc156, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc302(x64Operand& operand, int tokenPos) { operand.addressCoding = 31; } -x64Token x64Parser::tokenBranches301[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc302, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc448(x64Operand& operand, int tokenPos) { operand.addressCoding = 46; } -x64Token x64Parser::tokenBranches447[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc448, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc28(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc155(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc301(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc447(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4140[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4141, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 338; } -x64Token x64Parser::tokenBranches27[] = { - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc28, x64Parser::tokenBranches28}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc155, x64Parser::tokenBranches155}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc301, x64Parser::tokenBranches301}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc447, x64Parser::tokenBranches447}, - {x64Token::EOT}}; -void x64Parser::TokenFunc110(x64Operand& operand, int tokenPos) { operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches26[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches27}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc250(x64Operand& operand, int tokenPos) { operand.addressCoding = 25; } -x64Token x64Parser::tokenBranches249[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc250, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc396(x64Operand& operand, int tokenPos) { operand.addressCoding = 40; } -x64Token x64Parser::tokenBranches395[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc396, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc249(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc395(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4150, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4131(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches248[] = { - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc249, x64Parser::tokenBranches249}, - {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc395, x64Parser::tokenBranches395}, - {x64Token::EOT}}; -void x64Parser::TokenFunc74(x64Operand& operand, int tokenPos) { operand.addressCoding = 10; } -x64Token x64Parser::tokenBranches73[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData2, - &x64Parser::TokenFunc74, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches248}, - {x64Token::EOT}}; -void x64Parser::TokenFunc580(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches579[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc580, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc690(x64Operand& operand, int tokenPos) { operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches689[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc690, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc814(x64Operand& operand, int tokenPos) { operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches813[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc814, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2083(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2082[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2083, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2615(x64Operand& operand, int tokenPos) { operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2614[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2615, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2913(x64Operand& operand, int tokenPos) { operand.addressCoding = 222; } -x64Token x64Parser::tokenBranches2912[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2913, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2082(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2614(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2912(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4140(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2081[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2082, x64Parser::tokenBranches2082}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2614, x64Parser::tokenBranches2614}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2912, x64Parser::tokenBranches2912}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2373(x64Operand& operand, int tokenPos) { operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches2080[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2081}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2373, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2080(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc4149(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2079[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2080, x64Parser::tokenBranches2080}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2090(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2622(x64Operand& operand, int tokenPos) { operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches2621[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2622, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2920(x64Operand& operand, int tokenPos) { operand.addressCoding = 223; } -x64Token x64Parser::tokenBranches2919[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2920, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2089(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2621(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2919(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches4130[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4131, x64Parser::tokenBranches4131 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4140, x64Parser::tokenBranches4140 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4149, x64Parser::tokenBranches4149 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4123(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 336; +} +x64Token x64Parser::tokenBranches4122[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4123, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4130 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3994(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4122(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2088[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2089, x64Parser::tokenBranches2089}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2621, x64Parser::tokenBranches2621}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2919, x64Parser::tokenBranches2919}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2378(x64Operand& operand, int tokenPos) { operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches2078[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2079}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2088}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2378, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc579(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc689(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc813(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2078(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches3993[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3994, x64Parser::tokenBranches3994 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4122, x64Parser::tokenBranches4122 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3992[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3993 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc78(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc525(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc564(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches578[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc579, x64Parser::tokenBranches579}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc689, x64Parser::tokenBranches689}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc813, x64Parser::tokenBranches813}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2078, x64Parser::tokenBranches2078}, - {x64Token::EOT}}; -void x64Parser::TokenFunc472(x64Operand& operand, int tokenPos) { operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches471[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc472, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches578}, - {x64Token::EOT}}; -void x64Parser::TokenFunc585(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches584[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc585, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc695(x64Operand& operand, int tokenPos) { operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches694[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc695, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc819(x64Operand& operand, int tokenPos) { operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches818[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc819, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2058(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2057[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2058, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2590(x64Operand& operand, int tokenPos) { operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches2589[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2590, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2888(x64Operand& operand, int tokenPos) { operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches2887[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2888, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2057(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2589(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2887(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches33 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches54 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches505 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches510 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1219 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3736 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3992 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc8, x64Parser::tokenBranches8 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc78, x64Parser::tokenBranches78 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc525, x64Parser::tokenBranches525 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc564, x64Parser::tokenBranches564 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches7 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc14(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 2; +} +x64Token x64Parser::tokenBranches13[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc14, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc209(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 21; +} +x64Token x64Parser::tokenBranches208[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc209, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc355(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 36; +} +x64Token x64Parser::tokenBranches354[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc355, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc208(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc354(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2056[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2057, x64Parser::tokenBranches2057}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2589, x64Parser::tokenBranches2589}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2887, x64Parser::tokenBranches2887}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2354(x64Operand& operand, int tokenPos) { operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches2055[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2056}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2354, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2067(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2066[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2067, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2599(x64Operand& operand, int tokenPos) { operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches2598[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2599, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2897(x64Operand& operand, int tokenPos) { operand.addressCoding = 220; } -x64Token x64Parser::tokenBranches2896[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2897, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2066(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2598(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2896(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches207[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc208, x64Parser::tokenBranches208 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc354, x64Parser::tokenBranches354 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc43(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 6; +} +x64Token x64Parser::tokenBranches42[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc43, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches207 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc144(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 14; +} +x64Token x64Parser::tokenBranches143[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc144, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 29; +} +x64Token x64Parser::tokenBranches289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc290, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc436(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 44; +} +x64Token x64Parser::tokenBranches435[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc436, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc42(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc143(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc289(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc435(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2065[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2066, x64Parser::tokenBranches2066}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2598, x64Parser::tokenBranches2598}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2896, x64Parser::tokenBranches2896}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2361(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2064[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2065}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2361, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2064(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches41[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc42, x64Parser::tokenBranches42 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc143, x64Parser::tokenBranches143 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc289, x64Parser::tokenBranches289 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc435, x64Parser::tokenBranches435 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc102(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 14; } -x64Token x64Parser::tokenBranches2063[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2064, x64Parser::tokenBranches2064}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2074(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2073[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2074, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2606(x64Operand& operand, int tokenPos) { operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches2605[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2606, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2904(x64Operand& operand, int tokenPos) { operand.addressCoding = 221; } -x64Token x64Parser::tokenBranches2903[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2904, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2073(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2605(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2903(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches40[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches41 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc102, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 20; } -x64Token x64Parser::tokenBranches2072[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2073, x64Parser::tokenBranches2073}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2605, x64Parser::tokenBranches2605}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2903, x64Parser::tokenBranches2903}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2366(x64Operand& operand, int tokenPos) { operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches2062[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2063}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2072}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2366, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc584(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc694(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc818(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2062(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc364(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 35; } -x64Token x64Parser::tokenBranches583[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2055}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc584, x64Parser::tokenBranches584}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc694, x64Parser::tokenBranches694}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc818, x64Parser::tokenBranches818}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2062, x64Parser::tokenBranches2062}, - {x64Token::EOT}}; -void x64Parser::TokenFunc945(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc952(x64Operand& operand, int tokenPos) { operand.addressCoding = 97; } -x64Token x64Parser::tokenBranches951[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc952, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc959(x64Operand& operand, int tokenPos) { operand.addressCoding = 98; } -x64Token x64Parser::tokenBranches958[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc959, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc944(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc951(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc958(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches363[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc364, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc217(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches943[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc944, x64Parser::tokenBranches944}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc951, x64Parser::tokenBranches951}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc958, x64Parser::tokenBranches958}, - {x64Token::EOT}}; -void x64Parser::TokenFunc938(x64Operand& operand, int tokenPos) { operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches937[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc938, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches943}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1073(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1072[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1073, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1080(x64Operand& operand, int tokenPos) { operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches1079[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1080, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1087(x64Operand& operand, int tokenPos) { operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches1086[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1087, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1072(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1079(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1086(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc363(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1071[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1072, x64Parser::tokenBranches1072}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1079, x64Parser::tokenBranches1079}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1086, x64Parser::tokenBranches1086}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1066(x64Operand& operand, int tokenPos) { operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches1065[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1066, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1071}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1457(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1456[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1457, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1464(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1463[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1464, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1456(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1463(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches216[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc217, x64Parser::tokenBranches217 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc363, x64Parser::tokenBranches363 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc50(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 5; +} +x64Token x64Parser::tokenBranches49[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc50, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches216 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc163(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches162[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc163, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc309(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 31; +} +x64Token x64Parser::tokenBranches308[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc309, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc455(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 46; +} +x64Token x64Parser::tokenBranches454[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc455, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc49(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc162(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc308(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc454(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1455[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1456, x64Parser::tokenBranches1456}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1463, x64Parser::tokenBranches1463}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1450(x64Operand& operand, int tokenPos) { operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches1449[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1450, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1455}, - {x64Token::EOT}}; -void x64Parser::TokenFunc937(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1065(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1449(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches48[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc49, x64Parser::tokenBranches49 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc162, x64Parser::tokenBranches162 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc308, x64Parser::tokenBranches308 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc454, x64Parser::tokenBranches454 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc115(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; } -x64Token x64Parser::tokenBranches936[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc937, x64Parser::tokenBranches937}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1065, x64Parser::tokenBranches1065}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1449, x64Parser::tokenBranches1449}, - {x64Token::EOT}}; -void x64Parser::TokenFunc475(x64Operand& operand, int tokenPos) { operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches474[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc475, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches583}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches936}, - {x64Token::EOT}}; -void x64Parser::TokenFunc618(x64Operand& operand, int tokenPos) { operand.addressCoding = 51; } -x64Token x64Parser::tokenBranches617[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc618, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc742(x64Operand& operand, int tokenPos) { operand.addressCoding = 74; } -x64Token x64Parser::tokenBranches741[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc742, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc866(x64Operand& operand, int tokenPos) { operand.addressCoding = 88; } -x64Token x64Parser::tokenBranches865[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc866, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2246(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2245[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2778(x64Operand& operand, int tokenPos) { operand.addressCoding = 208; } -x64Token x64Parser::tokenBranches2777[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3076(x64Operand& operand, int tokenPos) { operand.addressCoding = 234; } -x64Token x64Parser::tokenBranches3075[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3076, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2245(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2777(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3075(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches47[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches48 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc115, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc264(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 26; } -x64Token x64Parser::tokenBranches2244[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2245, x64Parser::tokenBranches2245}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2777, x64Parser::tokenBranches2777}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3075, x64Parser::tokenBranches3075}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2502(x64Operand& operand, int tokenPos) { operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches2243[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2244}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2502, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2243(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches263[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc264, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc410(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 41; } -x64Token x64Parser::tokenBranches2242[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2243, x64Parser::tokenBranches2243}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2253(x64Operand& operand, int tokenPos) { operand.addressCoding = 184; } -x64Token x64Parser::tokenBranches2252[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2253, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2785(x64Operand& operand, int tokenPos) { operand.addressCoding = 209; } -x64Token x64Parser::tokenBranches2784[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2785, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3083(x64Operand& operand, int tokenPos) { operand.addressCoding = 235; } -x64Token x64Parser::tokenBranches3082[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3083, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2252(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2784(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3082(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches409[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc410, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc263(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2251[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2252, x64Parser::tokenBranches2252}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2784, x64Parser::tokenBranches2784}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3082, x64Parser::tokenBranches3082}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2507(x64Operand& operand, int tokenPos) { operand.addressCoding = 184; } -x64Token x64Parser::tokenBranches2241[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2242}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2251}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2507, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc617(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc741(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc865(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2241(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc409(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches616[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc617, x64Parser::tokenBranches617}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc741, x64Parser::tokenBranches741}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc865, x64Parser::tokenBranches865}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2241, x64Parser::tokenBranches2241}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1201(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1200[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1201, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1208(x64Operand& operand, int tokenPos) { operand.addressCoding = 115; } -x64Token x64Parser::tokenBranches1207[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1208, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1215(x64Operand& operand, int tokenPos) { operand.addressCoding = 116; } -x64Token x64Parser::tokenBranches1214[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1215, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1200(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1207(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1214(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches262[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc263, x64Parser::tokenBranches263 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc409, x64Parser::tokenBranches409 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc84(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 11; } -x64Token x64Parser::tokenBranches1199[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1200, x64Parser::tokenBranches1200}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1207, x64Parser::tokenBranches1207}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1214, x64Parser::tokenBranches1214}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1194(x64Operand& operand, int tokenPos) { operand.addressCoding = 114; } -x64Token x64Parser::tokenBranches1193[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1194, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1199}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1329(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1328[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1329, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1336(x64Operand& operand, int tokenPos) { operand.addressCoding = 124; } -x64Token x64Parser::tokenBranches1335[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1336, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1343(x64Operand& operand, int tokenPos) { operand.addressCoding = 125; } -x64Token x64Parser::tokenBranches1342[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1343, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1328(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1335(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1342(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches83[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc84, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches262 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc592(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches1327[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1328, x64Parser::tokenBranches1328}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1335, x64Parser::tokenBranches1335}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1342, x64Parser::tokenBranches1342}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1322(x64Operand& operand, int tokenPos) { operand.addressCoding = 123; } -x64Token x64Parser::tokenBranches1321[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1322, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1327}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1551(x64Operand& operand, int tokenPos) { operand.addressCoding = 138; } -x64Token x64Parser::tokenBranches1550[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1558(x64Operand& operand, int tokenPos) { operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches1557[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1558, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1550(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1557(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches591[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc592, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc716(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 68; } -x64Token x64Parser::tokenBranches1549[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1550, x64Parser::tokenBranches1550}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1557, x64Parser::tokenBranches1557}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1544(x64Operand& operand, int tokenPos) { operand.addressCoding = 138; } -x64Token x64Parser::tokenBranches1543[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1544, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1549}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1193(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1321(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1543(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches715[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc716, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc840(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 82; } -x64Token x64Parser::tokenBranches1192[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1193, x64Parser::tokenBranches1193}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1321, x64Parser::tokenBranches1321}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1543, x64Parser::tokenBranches1543}, - {x64Token::EOT}}; -void x64Parser::TokenFunc478(x64Operand& operand, int tokenPos) { operand.addressCoding = 51; } -x64Token x64Parser::tokenBranches477[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc478, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches616}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1192}, - {x64Token::EOT}}; -void x64Parser::TokenFunc630(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches629[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc630, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc754(x64Operand& operand, int tokenPos) { operand.addressCoding = 76; } -x64Token x64Parser::tokenBranches753[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc754, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc878(x64Operand& operand, int tokenPos) { operand.addressCoding = 90; } -x64Token x64Parser::tokenBranches877[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc878, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc629(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc753(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc877(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches839[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc840, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2161(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches628[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc629, x64Parser::tokenBranches629}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc753, x64Parser::tokenBranches753}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc877, x64Parser::tokenBranches877}, - {x64Token::EOT}}; -void x64Parser::TokenFunc486(x64Operand& operand, int tokenPos) { operand.addressCoding = 53; } -x64Token x64Parser::tokenBranches485[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc486, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches628}, - {x64Token::EOT}}; -void x64Parser::TokenFunc623(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc623, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc747(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches746[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc747, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc871(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches870[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2262(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2261[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2262, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2794(x64Operand& operand, int tokenPos) { operand.addressCoding = 210; } -x64Token x64Parser::tokenBranches2793[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2794, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3092(x64Operand& operand, int tokenPos) { operand.addressCoding = 236; } -x64Token x64Parser::tokenBranches3091[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3092, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2261(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2793(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3091(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2160[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2161, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2720(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 196; } -x64Token x64Parser::tokenBranches2260[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2261, x64Parser::tokenBranches2261}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2793, x64Parser::tokenBranches2793}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3091, x64Parser::tokenBranches3091}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2514(x64Operand& operand, int tokenPos) { operand.addressCoding = 185; } -x64Token x64Parser::tokenBranches2259[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2260}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2514, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2259(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2719[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2720, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2991(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 226; } -x64Token x64Parser::tokenBranches2258[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2259, x64Parser::tokenBranches2259}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2269(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2268[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2269, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2801(x64Operand& operand, int tokenPos) { operand.addressCoding = 211; } -x64Token x64Parser::tokenBranches2800[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2801, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3099(x64Operand& operand, int tokenPos) { operand.addressCoding = 237; } -x64Token x64Parser::tokenBranches3098[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3099, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc2268(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2800(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3098(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2990[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2991, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2160(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2267[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2268, x64Parser::tokenBranches2268}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2800, x64Parser::tokenBranches2800}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3098, x64Parser::tokenBranches3098}, - {x64Token::EOT}}; -void x64Parser::TokenFunc2519(x64Operand& operand, int tokenPos) { operand.addressCoding = 186; } -x64Token x64Parser::tokenBranches2257[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2258}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2267}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc2519, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc622(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc746(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc870(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc2257(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2719(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches484[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches485}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc622, x64Parser::tokenBranches622}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc746, x64Parser::tokenBranches746}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc870, x64Parser::tokenBranches870}, - {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2257, x64Parser::tokenBranches2257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1595(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1594[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1595, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1602(x64Operand& operand, int tokenPos) { operand.addressCoding = 75; } -x64Token x64Parser::tokenBranches1601[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1602, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1609(x64Operand& operand, int tokenPos) { operand.addressCoding = 89; } -x64Token x64Parser::tokenBranches1608[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1609, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1594(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1601(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1608(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2990(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1593[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1594, x64Parser::tokenBranches1594}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1601, x64Parser::tokenBranches1601}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1608, x64Parser::tokenBranches1608}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1588(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches1587[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1588, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1593}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1723(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1722[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1723, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1730(x64Operand& operand, int tokenPos) { operand.addressCoding = 148; } -x64Token x64Parser::tokenBranches1729[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1737(x64Operand& operand, int tokenPos) { operand.addressCoding = 149; } -x64Token x64Parser::tokenBranches1736[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1737, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1722(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1729(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1736(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2159[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2160, x64Parser::tokenBranches2160 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2719, x64Parser::tokenBranches2719 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2990, x64Parser::tokenBranches2990 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2435(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; } -x64Token x64Parser::tokenBranches1721[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1722, x64Parser::tokenBranches1722}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1729, x64Parser::tokenBranches1729}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1736, x64Parser::tokenBranches1736}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1716(x64Operand& operand, int tokenPos) { operand.addressCoding = 147; } -x64Token x64Parser::tokenBranches1715[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1716, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1721}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1851(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1850[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1851, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1858(x64Operand& operand, int tokenPos) { operand.addressCoding = 157; } -x64Token x64Parser::tokenBranches1857[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1858, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1874(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1873[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1874, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1883(x64Operand& operand, int tokenPos) { operand.addressCoding = 159; } -x64Token x64Parser::tokenBranches1882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1883, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc1873(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1882(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2158[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2159 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2435, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2158(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches1872[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1873, x64Parser::tokenBranches1873}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1882, x64Parser::tokenBranches1882}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1865(x64Operand& operand, int tokenPos) { operand.addressCoding = 158; } -x64Token x64Parser::tokenBranches1864[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1865, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1872}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1850(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1857(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2157[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2158, x64Parser::tokenBranches2158 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; } -x64Token x64Parser::tokenBranches1849[] = { - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1864}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1850, x64Parser::tokenBranches1850}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1857, x64Parser::tokenBranches1857}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1844(x64Operand& operand, int tokenPos) { operand.addressCoding = 156; } -x64Token x64Parser::tokenBranches1843[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc1844, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1849}, - {x64Token::EOT}}; -void x64Parser::TokenFunc1587(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1715(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc1843(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2729(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 197; } -x64Token x64Parser::tokenBranches1586[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1587, x64Parser::tokenBranches1587}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1715, x64Parser::tokenBranches1715}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1843, x64Parser::tokenBranches1843}, - {x64Token::EOT}}; -void x64Parser::TokenFunc481(x64Operand& operand, int tokenPos) { operand.addressCoding = 52; } -x64Token x64Parser::tokenBranches480[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc481, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches484}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1586}, - {x64Token::EOT}}; -void x64Parser::TokenFunc560(x64Operand& operand, int tokenPos) { operand.addressCoding = 63; } -x64Token x64Parser::tokenBranches559[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData4, - &x64Parser::TokenFunc560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3261(x64Operand& operand, int tokenPos) { operand.addressCoding = 244; } -x64Token x64Parser::tokenBranches3260[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3261, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3351(x64Operand& operand, int tokenPos) { operand.addressCoding = 261; } -x64Token x64Parser::tokenBranches3350[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3351, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3443(x64Operand& operand, int tokenPos) { operand.addressCoding = 275; } -x64Token x64Parser::tokenBranches3442[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3443, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4515(x64Operand& operand, int tokenPos) { operand.addressCoding = 373; } -x64Token x64Parser::tokenBranches4514[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4515, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4891(x64Operand& operand, int tokenPos) { operand.addressCoding = 397; } -x64Token x64Parser::tokenBranches4890[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4891, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5103(x64Operand& operand, int tokenPos) { operand.addressCoding = 421; } -x64Token x64Parser::tokenBranches5102[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5103, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4514(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4890(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5102(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2728[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2729, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3000(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 227; } -x64Token x64Parser::tokenBranches4513[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4514, x64Parser::tokenBranches4514}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4890, x64Parser::tokenBranches4890}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5102, x64Parser::tokenBranches5102}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4713(x64Operand& operand, int tokenPos) { operand.addressCoding = 373; } -x64Token x64Parser::tokenBranches4512[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4513}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4713, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4512(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2999[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3000, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2169(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4511[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4512, x64Parser::tokenBranches4512}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4522(x64Operand& operand, int tokenPos) { operand.addressCoding = 374; } -x64Token x64Parser::tokenBranches4521[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4522, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4898(x64Operand& operand, int tokenPos) { operand.addressCoding = 398; } -x64Token x64Parser::tokenBranches4897[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4898, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5110(x64Operand& operand, int tokenPos) { operand.addressCoding = 422; } -x64Token x64Parser::tokenBranches5109[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5110, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4521(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4897(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5109(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2728(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4520[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4521, x64Parser::tokenBranches4521}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4897, x64Parser::tokenBranches4897}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5109, x64Parser::tokenBranches5109}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4718(x64Operand& operand, int tokenPos) { operand.addressCoding = 374; } -x64Token x64Parser::tokenBranches4510[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4511}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4520}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4718, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3260(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3350(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3442(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4510(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2999(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3259[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3260, x64Parser::tokenBranches3260}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3350, x64Parser::tokenBranches3350}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3442, x64Parser::tokenBranches3442}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4510, x64Parser::tokenBranches4510}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3182(x64Operand& operand, int tokenPos) { operand.addressCoding = 244; } -x64Token x64Parser::tokenBranches3181[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3182, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3259}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3307(x64Operand& operand, int tokenPos) { operand.addressCoding = 253; } -x64Token x64Parser::tokenBranches3306[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3307, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3399(x64Operand& operand, int tokenPos) { operand.addressCoding = 269; } -x64Token x64Parser::tokenBranches3398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3399, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3491(x64Operand& operand, int tokenPos) { operand.addressCoding = 283; } -x64Token x64Parser::tokenBranches3490[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3491, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3306(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3398(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3490(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2168[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2169, x64Parser::tokenBranches2169 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2728, x64Parser::tokenBranches2728 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2999, x64Parser::tokenBranches2999 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2442(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2156[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2157 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2168 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2442, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc591(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc715(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc839(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2156(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches3305[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3306, x64Parser::tokenBranches3306}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3398, x64Parser::tokenBranches3398}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3490, x64Parser::tokenBranches3490}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3219(x64Operand& operand, int tokenPos) { operand.addressCoding = 253; } -x64Token x64Parser::tokenBranches3218[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3219, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3356(x64Operand& operand, int tokenPos) { operand.addressCoding = 262; } -x64Token x64Parser::tokenBranches3355[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3356, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3448(x64Operand& operand, int tokenPos) { operand.addressCoding = 276; } -x64Token x64Parser::tokenBranches3447[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3448, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4531(x64Operand& operand, int tokenPos) { operand.addressCoding = 375; } -x64Token x64Parser::tokenBranches4530[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4531, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4907(x64Operand& operand, int tokenPos) { operand.addressCoding = 399; } -x64Token x64Parser::tokenBranches4906[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4907, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5119(x64Operand& operand, int tokenPos) { operand.addressCoding = 423; } -x64Token x64Parser::tokenBranches5118[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5119, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4530(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4906(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5118(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches590[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc591, x64Parser::tokenBranches591 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc715, x64Parser::tokenBranches715 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc839, x64Parser::tokenBranches839 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2156, x64Parser::tokenBranches2156 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc516(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; } -x64Token x64Parser::tokenBranches4529[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4530, x64Parser::tokenBranches4530}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4906, x64Parser::tokenBranches4906}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5118, x64Parser::tokenBranches5118}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4725(x64Operand& operand, int tokenPos) { operand.addressCoding = 375; } -x64Token x64Parser::tokenBranches4528[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4529}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4725, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4528(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches515[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc516, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches590 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc599(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; } -x64Token x64Parser::tokenBranches4527[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4528, x64Parser::tokenBranches4528}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4538(x64Operand& operand, int tokenPos) { operand.addressCoding = 376; } -x64Token x64Parser::tokenBranches4537[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4538, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4914(x64Operand& operand, int tokenPos) { operand.addressCoding = 400; } -x64Token x64Parser::tokenBranches4913[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4914, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5126(x64Operand& operand, int tokenPos) { operand.addressCoding = 424; } -x64Token x64Parser::tokenBranches5125[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5126, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4537(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4913(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5125(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches598[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc599, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc723(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 69; } -x64Token x64Parser::tokenBranches4536[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4537, x64Parser::tokenBranches4537}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4913, x64Parser::tokenBranches4913}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5125, x64Parser::tokenBranches5125}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4730(x64Operand& operand, int tokenPos) { operand.addressCoding = 376; } -x64Token x64Parser::tokenBranches4526[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4527}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4536}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4730, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3355(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3447(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4526(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches722[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc723, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc847(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 83; } -x64Token x64Parser::tokenBranches3217[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3218}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3355, x64Parser::tokenBranches3355}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3447, x64Parser::tokenBranches3447}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4526, x64Parser::tokenBranches4526}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3265(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3264[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3265, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3542(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3541[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3542, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3549(x64Operand& operand, int tokenPos) { operand.addressCoding = 262; } -x64Token x64Parser::tokenBranches3548[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3549, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3556(x64Operand& operand, int tokenPos) { operand.addressCoding = 276; } -x64Token x64Parser::tokenBranches3555[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3556, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3541(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3548(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3555(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches846[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc847, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2141(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches3540[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3541, x64Parser::tokenBranches3541}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3548, x64Parser::tokenBranches3548}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3555, x64Parser::tokenBranches3555}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3535(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -x64Token x64Parser::tokenBranches3534[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3535, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3540}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3602(x64Operand& operand, int tokenPos) { operand.addressCoding = 292; } -x64Token x64Parser::tokenBranches3601[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3602, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3609(x64Operand& operand, int tokenPos) { operand.addressCoding = 293; } -x64Token x64Parser::tokenBranches3608[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3609, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3616(x64Operand& operand, int tokenPos) { operand.addressCoding = 294; } -x64Token x64Parser::tokenBranches3615[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3616, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3601(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3608(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3615(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2140[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2141, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2700(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 194; } -x64Token x64Parser::tokenBranches3600[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3601, x64Parser::tokenBranches3601}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3608, x64Parser::tokenBranches3608}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3615, x64Parser::tokenBranches3615}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3595(x64Operand& operand, int tokenPos) { operand.addressCoding = 292; } -x64Token x64Parser::tokenBranches3594[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3595, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3600}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3662(x64Operand& operand, int tokenPos) { operand.addressCoding = 299; } -x64Token x64Parser::tokenBranches3661[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3662, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3661(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2699[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2700, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2971(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 224; } -x64Token x64Parser::tokenBranches3660[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3661, x64Parser::tokenBranches3661}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3655(x64Operand& operand, int tokenPos) { operand.addressCoding = 298; } -x64Token x64Parser::tokenBranches3654[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3655, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3660}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3690(x64Operand& operand, int tokenPos) { operand.addressCoding = 303; } -x64Token x64Parser::tokenBranches3689[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3690, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3689(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2970[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2971, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2140(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3688[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3689, x64Parser::tokenBranches3689}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3683(x64Operand& operand, int tokenPos) { operand.addressCoding = 302; } -x64Token x64Parser::tokenBranches3682[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3683, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3688}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3534(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3594(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3654(x64Operand& operand, int tokenPos) -{ - operand.values[13] = new Coding[2]; - CleanupValues.push_back(operand.values[13]); - operand.values[13]->type = Coding::number; - operand.values[13]->val = operands.size(); - operand.values[13]->bits = 0; - operand.values[13]->field = 0; - operand.values[13]->unary = 0; - operand.values[13]->binary = 0; - operand.values[13][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3682(x64Operand& operand, int tokenPos) -{ - operand.values[14] = new Coding[2]; - CleanupValues.push_back(operand.values[14]); - operand.values[14]->type = Coding::number; - operand.values[14]->val = operands.size(); - operand.values[14]->bits = 0; - operand.values[14]->field = 0; - operand.values[14]->unary = 0; - operand.values[14]->binary = 0; - operand.values[14][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2699(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3533[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3534, x64Parser::tokenBranches3534}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3594, x64Parser::tokenBranches3594}, - {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3654, x64Parser::tokenBranches3654}, - {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3682, x64Parser::tokenBranches3682}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3185(x64Operand& operand, int tokenPos) { operand.addressCoding = 245; } -void x64Parser::TokenFunc3264(x64Operand& operand, int tokenPos) -{ - operand.values[12] = new Coding[2]; - CleanupValues.push_back(operand.values[12]); - operand.values[12]->type = Coding::number; - operand.values[12]->val = operands.size(); - operand.values[12]->bits = 0; - operand.values[12]->field = 0; - operand.values[12]->unary = 0; - operand.values[12]->binary = 0; - operand.values[12][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2970(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3184[] = { - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3185, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3217}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3264, x64Parser::tokenBranches3264}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3533}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3270(x64Operand& operand, int tokenPos) { operand.addressCoding = 246; } -x64Token x64Parser::tokenBranches3269[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3270, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3361(x64Operand& operand, int tokenPos) { operand.addressCoding = 263; } -x64Token x64Parser::tokenBranches3360[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3361, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3453(x64Operand& operand, int tokenPos) { operand.addressCoding = 277; } -x64Token x64Parser::tokenBranches3452[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3453, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4465(x64Operand& operand, int tokenPos) { operand.addressCoding = 367; } -x64Token x64Parser::tokenBranches4464[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4465, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4841(x64Operand& operand, int tokenPos) { operand.addressCoding = 391; } -x64Token x64Parser::tokenBranches4840[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4841, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5053(x64Operand& operand, int tokenPos) { operand.addressCoding = 415; } -x64Token x64Parser::tokenBranches5052[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5053, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4464(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4840(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5052(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2139[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2140, x64Parser::tokenBranches2140 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2699, x64Parser::tokenBranches2699 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2970, x64Parser::tokenBranches2970 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2419(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; } -x64Token x64Parser::tokenBranches4463[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4464, x64Parser::tokenBranches4464}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4840, x64Parser::tokenBranches4840}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5052, x64Parser::tokenBranches5052}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4675(x64Operand& operand, int tokenPos) { operand.addressCoding = 367; } -x64Token x64Parser::tokenBranches4462[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4463}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4675, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4499(x64Operand& operand, int tokenPos) { operand.addressCoding = 371; } -x64Token x64Parser::tokenBranches4498[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4499, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4875(x64Operand& operand, int tokenPos) { operand.addressCoding = 395; } -x64Token x64Parser::tokenBranches4874[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4875, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5087(x64Operand& operand, int tokenPos) { operand.addressCoding = 419; } -x64Token x64Parser::tokenBranches5086[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5087, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4498(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4874(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5086(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2138[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2139 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2419, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2138(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4497[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4498, x64Parser::tokenBranches4498}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4874, x64Parser::tokenBranches4874}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5086, x64Parser::tokenBranches5086}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4701(x64Operand& operand, int tokenPos) { operand.addressCoding = 371; } -x64Token x64Parser::tokenBranches4496[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4497}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4701, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4496(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2137[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2138, x64Parser::tokenBranches2138 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches4495[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4496, x64Parser::tokenBranches4496}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4506(x64Operand& operand, int tokenPos) { operand.addressCoding = 372; } -x64Token x64Parser::tokenBranches4505[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4506, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4882(x64Operand& operand, int tokenPos) { operand.addressCoding = 396; } -x64Token x64Parser::tokenBranches4881[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4882, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5094(x64Operand& operand, int tokenPos) { operand.addressCoding = 420; } -x64Token x64Parser::tokenBranches5093[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5094, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4505(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4881(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5093(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2150, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2709(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 195; } -x64Token x64Parser::tokenBranches4504[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4505, x64Parser::tokenBranches4505}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4881, x64Parser::tokenBranches4881}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5093, x64Parser::tokenBranches5093}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4706(x64Operand& operand, int tokenPos) { operand.addressCoding = 372; } -x64Token x64Parser::tokenBranches4494[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4495}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4504}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4706, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3269(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3360(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3452(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4494(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +x64Token x64Parser::tokenBranches2708[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2709, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2980(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 225; } -x64Token x64Parser::tokenBranches3268[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4462}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3269, x64Parser::tokenBranches3269}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3360, x64Parser::tokenBranches3360}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3452, x64Parser::tokenBranches3452}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4494, x64Parser::tokenBranches4494}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3718(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3717[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3718, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3725(x64Operand& operand, int tokenPos) { operand.addressCoding = 307; } -x64Token x64Parser::tokenBranches3724[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3725, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3732(x64Operand& operand, int tokenPos) { operand.addressCoding = 308; } -x64Token x64Parser::tokenBranches3731[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3732, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3717(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3724(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3731(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2979[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2980, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2149(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3716[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3717, x64Parser::tokenBranches3717}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3724, x64Parser::tokenBranches3724}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3731, x64Parser::tokenBranches3731}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3711(x64Operand& operand, int tokenPos) { operand.addressCoding = 306; } -x64Token x64Parser::tokenBranches3710[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3711, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3716}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3846(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3845[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3846, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3853(x64Operand& operand, int tokenPos) { operand.addressCoding = 316; } -x64Token x64Parser::tokenBranches3852[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3853, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3860(x64Operand& operand, int tokenPos) { operand.addressCoding = 317; } -x64Token x64Parser::tokenBranches3859[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3860, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3845(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3852(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3859(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2708(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3844[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3845, x64Parser::tokenBranches3845}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3852, x64Parser::tokenBranches3852}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3859, x64Parser::tokenBranches3859}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3839(x64Operand& operand, int tokenPos) { operand.addressCoding = 315; } -x64Token x64Parser::tokenBranches3838[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3839, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3844}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4230(x64Operand& operand, int tokenPos) { operand.addressCoding = 343; } -x64Token x64Parser::tokenBranches4229[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4230, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4229(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc2979(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4228[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4229, x64Parser::tokenBranches4229}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4223(x64Operand& operand, int tokenPos) { operand.addressCoding = 342; } -x64Token x64Parser::tokenBranches4222[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4223, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4228}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3710(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3838(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4222(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2148[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2149, x64Parser::tokenBranches2149 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2708, x64Parser::tokenBranches2708 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2979, x64Parser::tokenBranches2979 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2426(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; } -x64Token x64Parser::tokenBranches3709[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3710, x64Parser::tokenBranches3710}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3838, x64Parser::tokenBranches3838}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4222, x64Parser::tokenBranches4222}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3188(x64Operand& operand, int tokenPos) { operand.addressCoding = 246; } -x64Token x64Parser::tokenBranches3187[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3188, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3268}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3709}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3295(x64Operand& operand, int tokenPos) { operand.addressCoding = 247; } -x64Token x64Parser::tokenBranches3294[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3295, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3387(x64Operand& operand, int tokenPos) { operand.addressCoding = 267; } -x64Token x64Parser::tokenBranches3386[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3479(x64Operand& operand, int tokenPos) { operand.addressCoding = 281; } -x64Token x64Parser::tokenBranches3478[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3479, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4472(x64Operand& operand, int tokenPos) { operand.addressCoding = 368; } -x64Token x64Parser::tokenBranches4471[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4472, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4848(x64Operand& operand, int tokenPos) { operand.addressCoding = 392; } -x64Token x64Parser::tokenBranches4847[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4848, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5060(x64Operand& operand, int tokenPos) { operand.addressCoding = 416; } -x64Token x64Parser::tokenBranches5059[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5060, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4471(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4847(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5059(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2136[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2137 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2148 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2426, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2228(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; } -x64Token x64Parser::tokenBranches4470[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4471, x64Parser::tokenBranches4471}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4847, x64Parser::tokenBranches4847}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5059, x64Parser::tokenBranches5059}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4680(x64Operand& operand, int tokenPos) { operand.addressCoding = 368; } -x64Token x64Parser::tokenBranches4469[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4470}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4680, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4607(x64Operand& operand, int tokenPos) { operand.addressCoding = 383; } -x64Token x64Parser::tokenBranches4606[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4607, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4983(x64Operand& operand, int tokenPos) { operand.addressCoding = 407; } -x64Token x64Parser::tokenBranches4982[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4983, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5195(x64Operand& operand, int tokenPos) { operand.addressCoding = 431; } -x64Token x64Parser::tokenBranches5194[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5195, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4606(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4982(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5194(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2227[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2228, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2640(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 193; } -x64Token x64Parser::tokenBranches4605[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4606, x64Parser::tokenBranches4606}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4982, x64Parser::tokenBranches4982}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5194, x64Parser::tokenBranches5194}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4785(x64Operand& operand, int tokenPos) { operand.addressCoding = 383; } -x64Token x64Parser::tokenBranches4604[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4605}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4785, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4604(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2639[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2640, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3018(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 219; } -x64Token x64Parser::tokenBranches4603[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4604, x64Parser::tokenBranches4604}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4614(x64Operand& operand, int tokenPos) { operand.addressCoding = 384; } -x64Token x64Parser::tokenBranches4613[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4614, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4990(x64Operand& operand, int tokenPos) { operand.addressCoding = 408; } -x64Token x64Parser::tokenBranches4989[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4990, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5202(x64Operand& operand, int tokenPos) { operand.addressCoding = 432; } -x64Token x64Parser::tokenBranches5201[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5202, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4613(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4989(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5201(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches3017[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3018, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2227(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4612[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4613, x64Parser::tokenBranches4613}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4989, x64Parser::tokenBranches4989}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5201, x64Parser::tokenBranches5201}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4790(x64Operand& operand, int tokenPos) { operand.addressCoding = 384; } -x64Token x64Parser::tokenBranches4602[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4603}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4612}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4790, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3294(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3386(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3478(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4602(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc2639(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3293[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4469}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3294, x64Parser::tokenBranches3294}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3386, x64Parser::tokenBranches3386}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3478, x64Parser::tokenBranches3478}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4602, x64Parser::tokenBranches4602}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3974(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches3973[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3974, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3981(x64Operand& operand, int tokenPos) { operand.addressCoding = 325; } -x64Token x64Parser::tokenBranches3980[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3981, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3988(x64Operand& operand, int tokenPos) { operand.addressCoding = 326; } -x64Token x64Parser::tokenBranches3987[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3988, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3973(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3980(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3987(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc3017(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3972[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3973, x64Parser::tokenBranches3973}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3980, x64Parser::tokenBranches3980}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3987, x64Parser::tokenBranches3987}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3967(x64Operand& operand, int tokenPos) { operand.addressCoding = 324; } -x64Token x64Parser::tokenBranches3966[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3967, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3972}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4102(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4101[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4109(x64Operand& operand, int tokenPos) { operand.addressCoding = 334; } -x64Token x64Parser::tokenBranches4108[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4109, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4116(x64Operand& operand, int tokenPos) { operand.addressCoding = 335; } -x64Token x64Parser::tokenBranches4115[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4116, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4101(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4108(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4115(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches2226[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2227, x64Parser::tokenBranches2227 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2639, x64Parser::tokenBranches2639 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3017, x64Parser::tokenBranches3017 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2456(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2225[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2226 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2456, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc598(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc722(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc846(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2136(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches4100[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4101, x64Parser::tokenBranches4101}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4108, x64Parser::tokenBranches4108}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4115, x64Parser::tokenBranches4115}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4095(x64Operand& operand, int tokenPos) { operand.addressCoding = 333; } -x64Token x64Parser::tokenBranches4094[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4095, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4100}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4258(x64Operand& operand, int tokenPos) { operand.addressCoding = 347; } -x64Token x64Parser::tokenBranches4257[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4258, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4257(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches597[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2225 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc598, x64Parser::tokenBranches598 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc722, x64Parser::tokenBranches722 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc846, x64Parser::tokenBranches846 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2136, x64Parser::tokenBranches2136 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1009(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches1008[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1009, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1018(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 97; +} +x64Token x64Parser::tokenBranches1017[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1018, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1027(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 98; +} +x64Token x64Parser::tokenBranches1026[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1027, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1008(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1017(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1026(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4256[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4257, x64Parser::tokenBranches4257}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4251(x64Operand& operand, int tokenPos) { operand.addressCoding = 346; } -x64Token x64Parser::tokenBranches4250[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4251, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4256}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3966(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4094(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4250(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1007[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1008, x64Parser::tokenBranches1008 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1017, x64Parser::tokenBranches1017 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1026, x64Parser::tokenBranches1026 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1000(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; } -x64Token x64Parser::tokenBranches3965[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3966, x64Parser::tokenBranches3966}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4094, x64Parser::tokenBranches4094}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4250, x64Parser::tokenBranches4250}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3191(x64Operand& operand, int tokenPos) { operand.addressCoding = 247; } -x64Token x64Parser::tokenBranches3190[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3191, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3293}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3965}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3314(x64Operand& operand, int tokenPos) { operand.addressCoding = 254; } -x64Token x64Parser::tokenBranches3313[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3314, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3406(x64Operand& operand, int tokenPos) { operand.addressCoding = 270; } -x64Token x64Parser::tokenBranches3405[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3406, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3498(x64Operand& operand, int tokenPos) { operand.addressCoding = 284; } -x64Token x64Parser::tokenBranches3497[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3498, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3313(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3405(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3497(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches999[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1000, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1007 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches3312[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3313, x64Parser::tokenBranches3313}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3405, x64Parser::tokenBranches3405}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3497, x64Parser::tokenBranches3497}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3224(x64Operand& operand, int tokenPos) { operand.addressCoding = 254; } -x64Token x64Parser::tokenBranches3223[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3224, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3312}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3300(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches3299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3392(x64Operand& operand, int tokenPos) { operand.addressCoding = 268; } -x64Token x64Parser::tokenBranches3391[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3392, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3484(x64Operand& operand, int tokenPos) { operand.addressCoding = 282; } -x64Token x64Parser::tokenBranches3483[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3484, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4623(x64Operand& operand, int tokenPos) { operand.addressCoding = 385; } -x64Token x64Parser::tokenBranches4622[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4623, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4999(x64Operand& operand, int tokenPos) { operand.addressCoding = 409; } -x64Token x64Parser::tokenBranches4998[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4999, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5211(x64Operand& operand, int tokenPos) { operand.addressCoding = 433; } -x64Token x64Parser::tokenBranches5210[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5211, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4622(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4998(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5210(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1146(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 106; } -x64Token x64Parser::tokenBranches4621[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4622, x64Parser::tokenBranches4622}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4998, x64Parser::tokenBranches4998}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5210, x64Parser::tokenBranches5210}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4797(x64Operand& operand, int tokenPos) { operand.addressCoding = 385; } -x64Token x64Parser::tokenBranches4620[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4621}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4797, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4620(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1145[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1155(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 107; } -x64Token x64Parser::tokenBranches4619[] = { - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4620, x64Parser::tokenBranches4620}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4630(x64Operand& operand, int tokenPos) { operand.addressCoding = 386; } -x64Token x64Parser::tokenBranches4629[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4630, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5006(x64Operand& operand, int tokenPos) { operand.addressCoding = 410; } -x64Token x64Parser::tokenBranches5005[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5006, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5218(x64Operand& operand, int tokenPos) { operand.addressCoding = 434; } -x64Token x64Parser::tokenBranches5217[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc5218, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4629(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5005(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5217(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1154[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1155, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1136(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4628[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4629, x64Parser::tokenBranches4629}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5005, x64Parser::tokenBranches5005}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5217, x64Parser::tokenBranches5217}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4802(x64Operand& operand, int tokenPos) { operand.addressCoding = 386; } -x64Token x64Parser::tokenBranches4618[] = {{x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4619}, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4628}, - { - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4802, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3299(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3391(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3483(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4618(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; +void x64Parser::TokenFunc1145(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3222[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3223}, - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3299, x64Parser::tokenBranches3299}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3391, x64Parser::tokenBranches3391}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3483, x64Parser::tokenBranches3483}, - {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4618, x64Parser::tokenBranches4618}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4286(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches4285[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4286, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4293(x64Operand& operand, int tokenPos) { operand.addressCoding = 268; } -x64Token x64Parser::tokenBranches4292[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4293, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4300(x64Operand& operand, int tokenPos) { operand.addressCoding = 282; } -x64Token x64Parser::tokenBranches4299[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4300, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4285(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4292(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4299(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1154(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4284[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4285, x64Parser::tokenBranches4285}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4292, x64Parser::tokenBranches4292}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4299, x64Parser::tokenBranches4299}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4279(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches4278[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4279, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4284}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4346(x64Operand& operand, int tokenPos) { operand.addressCoding = 353; } -x64Token x64Parser::tokenBranches4345[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4346, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4353(x64Operand& operand, int tokenPos) { operand.addressCoding = 354; } -x64Token x64Parser::tokenBranches4352[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4353, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4360(x64Operand& operand, int tokenPos) { operand.addressCoding = 355; } -x64Token x64Parser::tokenBranches4359[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4360, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4345(x64Operand& operand, int tokenPos) -{ - operand.values[4] = new Coding[2]; - CleanupValues.push_back(operand.values[4]); - operand.values[4]->type = Coding::number; - operand.values[4]->val = operands.size(); - operand.values[4]->bits = 0; - operand.values[4]->field = 0; - operand.values[4]->unary = 0; - operand.values[4]->binary = 0; - operand.values[4][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4352(x64Operand& operand, int tokenPos) -{ - operand.values[5] = new Coding[2]; - CleanupValues.push_back(operand.values[5]); - operand.values[5]->type = Coding::number; - operand.values[5]->val = operands.size(); - operand.values[5]->bits = 0; - operand.values[5]->field = 0; - operand.values[5]->unary = 0; - operand.values[5]->binary = 0; - operand.values[5][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4359(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1135[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1136, x64Parser::tokenBranches1136 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1145, x64Parser::tokenBranches1145 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1154, x64Parser::tokenBranches1154 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1128(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; } -x64Token x64Parser::tokenBranches4344[] = { - {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4345, x64Parser::tokenBranches4345}, - {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4352, x64Parser::tokenBranches4352}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4359, x64Parser::tokenBranches4359}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4339(x64Operand& operand, int tokenPos) { operand.addressCoding = 353; } -x64Token x64Parser::tokenBranches4338[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4339, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4344}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4406(x64Operand& operand, int tokenPos) { operand.addressCoding = 360; } -x64Token x64Parser::tokenBranches4405[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4406, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4422(x64Operand& operand, int tokenPos) { operand.addressCoding = 362; } -x64Token x64Parser::tokenBranches4421[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4422, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc4421(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1127[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1128, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1135 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1505(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; } -x64Token x64Parser::tokenBranches4420[] = { - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4421, x64Parser::tokenBranches4421}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4413(x64Operand& operand, int tokenPos) { operand.addressCoding = 361; } -x64Token x64Parser::tokenBranches4412[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4413, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4420}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4405(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1504[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1505, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1514(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; } -x64Token x64Parser::tokenBranches4404[] = { - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4412}, - {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4405, x64Parser::tokenBranches4405}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4399(x64Operand& operand, int tokenPos) { operand.addressCoding = 359; } -x64Token x64Parser::tokenBranches4398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc4399, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4404}, - {x64Token::EOT}}; -void x64Parser::TokenFunc4278(x64Operand& operand, int tokenPos) -{ - operand.values[7] = new Coding[2]; - CleanupValues.push_back(operand.values[7]); - operand.values[7]->type = Coding::number; - operand.values[7]->val = operands.size(); - operand.values[7]->bits = 0; - operand.values[7]->field = 0; - operand.values[7]->unary = 0; - operand.values[7]->binary = 0; - operand.values[7][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4338(x64Operand& operand, int tokenPos) -{ - operand.values[8] = new Coding[2]; - CleanupValues.push_back(operand.values[8]); - operand.values[8]->type = Coding::number; - operand.values[8]->val = operands.size(); - operand.values[8]->bits = 0; - operand.values[8]->field = 0; - operand.values[8]->unary = 0; - operand.values[8]->binary = 0; - operand.values[8][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc4398(x64Operand& operand, int tokenPos) -{ - operand.values[9] = new Coding[2]; - CleanupValues.push_back(operand.values[9]); - operand.values[9]->type = Coding::number; - operand.values[9]->val = operands.size(); - operand.values[9]->bits = 0; - operand.values[9]->field = 0; - operand.values[9]->unary = 0; - operand.values[9]->binary = 0; - operand.values[9][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1513[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1514, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1504(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches4277[] = { - {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4278, x64Parser::tokenBranches4278}, - {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4338, x64Parser::tokenBranches4338}, - {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4398, x64Parser::tokenBranches4398}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3214(x64Operand& operand, int tokenPos) { operand.addressCoding = 252; } -x64Token x64Parser::tokenBranches3213[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData3, - &x64Parser::TokenFunc3214, - }, - {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3222}, - {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3248(x64Operand& operand, int tokenPos) { operand.addressCoding = 258; } -x64Token x64Parser::tokenBranches3247[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3248, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3247(x64Operand& operand, int tokenPos) -{ - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc1513(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches3246[] = { - {x64Token::NUMBER, 15, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3247, x64Parser::tokenBranches3247}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches3245[] = {{x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3246}, - {x64Token::EOT}}; -void x64Parser::TokenFunc3251(x64Operand& operand, int tokenPos) { operand.addressCoding = 259; } -x64Token x64Parser::tokenBranches3250[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - x64Parser::RegClassData5, - &x64Parser::TokenFunc3251, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc3(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc16(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc73(x64Operand& operand, int tokenPos) -{ - operand.values[3] = new Coding[2]; - CleanupValues.push_back(operand.values[3]); - operand.values[3]->type = Coding::reg; - operand.values[3]->val = inputTokens[tokenPos]->val->ival; - operand.values[3]->bits = 0; - operand.values[3]->field = 0; - operand.values[3]->unary = 0; - operand.values[3]->binary = 0; - operand.values[3][1].type = Coding::eot; -} -void x64Parser::TokenFunc480(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc559(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc3213(x64Operand& operand, int tokenPos) -{ - operand.values[6] = new Coding[2]; - CleanupValues.push_back(operand.values[6]); - operand.values[6]->type = Coding::reg; - operand.values[6]->val = inputTokens[tokenPos]->val->ival; - operand.values[6]->bits = 0; - operand.values[6]->field = 0; - operand.values[6]->unary = 0; - operand.values[6]->binary = 0; - operand.values[6][1].type = Coding::eot; -} -void x64Parser::TokenFunc3250(x64Operand& operand, int tokenPos) -{ - operand.values[1] = new Coding[2]; - CleanupValues.push_back(operand.values[1]); - operand.values[1]->type = Coding::number; - operand.values[1]->val = operands.size(); - operand.values[1]->bits = 0; - operand.values[1]->field = 0; - operand.values[1]->unary = 0; - operand.values[1]->binary = 0; - operand.values[1][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches1503[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1504, x64Parser::tokenBranches1504 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1513, x64Parser::tokenBranches1513 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1496(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1495[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1496, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1503 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc999(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1127(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1495(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches2[] = { - {x64Token::REGISTER, 96, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches6}, - {x64Token::REGISTER, 95, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches11}, - {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches21}, - {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches26}, - {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches471}, - {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches474}, - {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches477}, - {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3181}, - {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3184}, - {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3187}, - {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3190}, - {x64Token::REGISTER, 68, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3245}, - {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc3, x64Parser::tokenBranches3}, - {x64Token::REGISTERCLASS, 19, 0, 0, x64Parser::RegClassData1, &x64Parser::TokenFunc16, x64Parser::tokenBranches16}, - {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc73, x64Parser::tokenBranches73}, - {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc480, x64Parser::tokenBranches480}, - {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc559, x64Parser::tokenBranches559}, - {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3213, x64Parser::tokenBranches3213}, - {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3250, x64Parser::tokenBranches3250}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5259(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 439; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5260(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5261(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 441; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5262(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5263(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5264(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5265(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 442; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5266(x64Operand& operand, int tokenPos) -{ - operand.addressCoding = 440; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches1[] = {{x64Token::TOKEN, 1, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches2}, - { - x64Token::REGISTERCLASS, - 20, - 1, - 0, - x64Parser::RegClassData6, - &x64Parser::TokenFunc5259, - }, - { - x64Token::REGISTERCLASS, - 1, - 1, - 0, - x64Parser::RegClassData7, - &x64Parser::TokenFunc5260, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - x64Parser::RegClassData8, - &x64Parser::TokenFunc5261, - }, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - x64Parser::RegClassData9, - &x64Parser::TokenFunc5262, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - x64Parser::RegClassData10, - &x64Parser::TokenFunc5263, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - x64Parser::RegClassData11, - &x64Parser::TokenFunc5264, - }, - { - x64Token::REGISTERCLASS, - 18, - 1, - 0, - x64Parser::RegClassData12, - &x64Parser::TokenFunc5265, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - x64Parser::RegClassData13, - &x64Parser::TokenFunc5266, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5268(x64Operand& operand, int tokenPos) { operand.operandCoding = 443; } -x64Token x64Parser::tokenBranches5267[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5268, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5270(x64Operand& operand, int tokenPos) { operand.operandCoding = 444; } -x64Token x64Parser::tokenBranches5269[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5270, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5275_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5275_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches998[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc999, x64Parser::tokenBranches999 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1127, x64Parser::tokenBranches1127 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1495, x64Parser::tokenBranches1495 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5275(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc521(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5275_16; - operand.values[17] = tokenCoding5275_17; - operand.values[18] = tokenCoding5275_18; - operand.values[19] = tokenCoding5275_19; + operand.addressCoding = 50; } -Coding x64Parser::tokenCoding5287_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc521, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches597 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches998 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 60; +} +x64Token x64Parser::tokenBranches668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc669, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc793(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 79; +} +x64Token x64Parser::tokenBranches792[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc793, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5287_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5287(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5287_16; - operand.values[17] = tokenCoding5287_17; - operand.values[18] = tokenCoding5287_18; - operand.values[19] = tokenCoding5287_19; -} -x64Token x64Parser::tokenBranches5274[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5275, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5287, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5273[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5272[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5273}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5279_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc917(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 93; +} +x64Token x64Parser::tokenBranches916[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc668(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc792(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc916(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches667[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc668, x64Parser::tokenBranches668 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc792, x64Parser::tokenBranches792 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc916, x64Parser::tokenBranches916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc545(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 60; +} +x64Token x64Parser::tokenBranches544[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc545, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches667 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5279_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc660(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 59; +} +x64Token x64Parser::tokenBranches659[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc660, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5279(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc784(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5279_16; - operand.values[17] = tokenCoding5279_17; - operand.values[18] = tokenCoding5279_18; - operand.values[19] = tokenCoding5279_19; + operand.addressCoding = 78; } -Coding x64Parser::tokenCoding5291_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches783[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc908(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 92; +} +x64Token x64Parser::tokenBranches907[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc908, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2320(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 189; +} +x64Token x64Parser::tokenBranches2319[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2320, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5291_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5291(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5291_16; - operand.values[17] = tokenCoding5291_17; - operand.values[18] = tokenCoding5291_18; - operand.values[19] = tokenCoding5291_19; -} -x64Token x64Parser::tokenBranches5278[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5279, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5291, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5277[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5276[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5277}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5283_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2852(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 215; +} +x64Token x64Parser::tokenBranches2851[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2852, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc3150(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 240; +} +x64Token x64Parser::tokenBranches3149[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3150, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2319(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2851(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3149(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2318[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2319, x64Parser::tokenBranches2319 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2851, x64Parser::tokenBranches2851 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3149, x64Parser::tokenBranches3149 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5283_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2560(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 189; +} +x64Token x64Parser::tokenBranches2317[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2318 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2560, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5283(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc2317(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5283_16; - operand.values[17] = tokenCoding5283_17; - operand.values[18] = tokenCoding5283_18; - operand.values[19] = tokenCoding5283_19; + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5295_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches2316[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2317, x64Parser::tokenBranches2317 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2329(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 190; +} +x64Token x64Parser::tokenBranches2328[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2329, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc2861(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 216; +} +x64Token x64Parser::tokenBranches2860[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2861, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5295_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5295(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5295_16; - operand.values[17] = tokenCoding5295_17; - operand.values[18] = tokenCoding5295_18; - operand.values[19] = tokenCoding5295_19; -} -x64Token x64Parser::tokenBranches5282[] = {{ - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5283, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5295, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5281[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5282}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5280[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5281}, {x64Token::EOT}}; -void x64Parser::TokenFunc5272(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5276(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5280(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc3159(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 241; } -x64Token x64Parser::tokenBranches5271[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5272, x64Parser::tokenBranches5272}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5276, x64Parser::tokenBranches5276}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5280, x64Parser::tokenBranches5280}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5300_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches3158[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3159, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2328(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2860(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3158(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2327[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2328, x64Parser::tokenBranches2328 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2860, x64Parser::tokenBranches2860 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3158, x64Parser::tokenBranches3158 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2567(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 190; +} +x64Token x64Parser::tokenBranches2315[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2316 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2327 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2567, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc659(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc783(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc907(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2315(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches543[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches544 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc659, x64Parser::tokenBranches659 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc783, x64Parser::tokenBranches783 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc907, x64Parser::tokenBranches907 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2315, x64Parser::tokenBranches2315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1659(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 141; +} +x64Token x64Parser::tokenBranches1658[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1659, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1668(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 142; +} +x64Token x64Parser::tokenBranches1667[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1668, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1677(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 143; +} +x64Token x64Parser::tokenBranches1676[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1677, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1658(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1667(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1676(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1657[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1658, x64Parser::tokenBranches1658 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1667, x64Parser::tokenBranches1667 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1676, x64Parser::tokenBranches1676 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 141; +} +x64Token x64Parser::tokenBranches1649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1650, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1657 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1787(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 150; +} +x64Token x64Parser::tokenBranches1786[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1787, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1796(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 151; +} +x64Token x64Parser::tokenBranches1795[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1796, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1805(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 152; +} +x64Token x64Parser::tokenBranches1804[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1805, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1786(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1795(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1804(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1785[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1786, x64Parser::tokenBranches1786 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1795, x64Parser::tokenBranches1795 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1804, x64Parser::tokenBranches1804 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 150; +} +x64Token x64Parser::tokenBranches1777[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1778, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1785 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1955(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 161; +} +x64Token x64Parser::tokenBranches1954[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1955, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1964(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 162; +} +x64Token x64Parser::tokenBranches1963[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1964, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1984(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 163; +} +x64Token x64Parser::tokenBranches1983[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1984, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1995(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 164; +} +x64Token x64Parser::tokenBranches1994[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1995, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1983(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1994(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1982[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1983, x64Parser::tokenBranches1983 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1994, x64Parser::tokenBranches1994 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1973(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 163; +} +x64Token x64Parser::tokenBranches1972[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1973, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1982 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1954(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1963(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1953[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1972 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1954, x64Parser::tokenBranches1954 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1963, x64Parser::tokenBranches1963 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1946(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 160; +} +x64Token x64Parser::tokenBranches1945[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1946, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1953 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1649(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1777(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1945(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1648[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1649, x64Parser::tokenBranches1649 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1777, x64Parser::tokenBranches1777 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1945, x64Parser::tokenBranches1945 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc531(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 59; +} +x64Token x64Parser::tokenBranches530[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc531, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches543 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1648 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc570(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 65; +} +x64Token x64Parser::tokenBranches569[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc570, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1265, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1274(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 115; +} +x64Token x64Parser::tokenBranches1273[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1274, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 116; +} +x64Token x64Parser::tokenBranches1282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1264(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1273(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1282(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1263[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1264, x64Parser::tokenBranches1264 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1273, x64Parser::tokenBranches1273 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1282, x64Parser::tokenBranches1282 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1256(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1255[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1256, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1263 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1393(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1392[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1393, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1402(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 124; +} +x64Token x64Parser::tokenBranches1401[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1402, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1411(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 125; +} +x64Token x64Parser::tokenBranches1410[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1411, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1392(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1401(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1410(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1391[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1392, x64Parser::tokenBranches1392 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1401, x64Parser::tokenBranches1401 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1410, x64Parser::tokenBranches1410 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1384(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1383[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1384, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1391 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1255(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1383(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1254[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1255, x64Parser::tokenBranches1255 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1383, x64Parser::tokenBranches1383 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches1253[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1254 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3782(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3781[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3782, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3791(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 307; +} +x64Token x64Parser::tokenBranches3790[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3791, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3800(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 308; +} +x64Token x64Parser::tokenBranches3799[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3800, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3781(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3790(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3799(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3780[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3781, x64Parser::tokenBranches3781 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3790, x64Parser::tokenBranches3790 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3799, x64Parser::tokenBranches3799 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3773(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3772[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3773, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3780 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3910(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3909[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3910, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3919(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 316; +} +x64Token x64Parser::tokenBranches3918[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3919, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3928(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 317; +} +x64Token x64Parser::tokenBranches3927[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3928, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3909(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3918(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3927(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3908[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3909, x64Parser::tokenBranches3909 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3918, x64Parser::tokenBranches3918 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3927, x64Parser::tokenBranches3927 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3901(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3900[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3901, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3908 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3772(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3900(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3771[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3772, x64Parser::tokenBranches3772 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3900, x64Parser::tokenBranches3900 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3770[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3771 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4038(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches4037[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4038, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4047(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 325; +} +x64Token x64Parser::tokenBranches4046[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4047, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4056(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 326; +} +x64Token x64Parser::tokenBranches4055[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4056, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4037(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4046(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4055(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4036[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4037, x64Parser::tokenBranches4037 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4046, x64Parser::tokenBranches4046 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4055, x64Parser::tokenBranches4055 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4029(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches4028[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4029, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4036 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4166(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4165[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4166, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4175(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 334; +} +x64Token x64Parser::tokenBranches4174[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4175, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4184(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 335; +} +x64Token x64Parser::tokenBranches4183[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4184, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4165(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4174(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4183(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4164[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4165, x64Parser::tokenBranches4165 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4174, x64Parser::tokenBranches4174 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4183, x64Parser::tokenBranches4183 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4157(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4156[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4157, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4164 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4028(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4156(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4027[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4028, x64Parser::tokenBranches4028 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4156, x64Parser::tokenBranches4156 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches4026[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4027 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc13(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc83(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc530(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc569(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches12[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches40 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches47 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches515 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches520 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1253 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3770 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4026 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc13, x64Parser::tokenBranches13 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc83, x64Parser::tokenBranches83 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc530, x64Parser::tokenBranches530 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc569, x64Parser::tokenBranches569 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches11[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches12 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc19(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 3; +} +x64Token x64Parser::tokenBranches18[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc19, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc236(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 23; +} +x64Token x64Parser::tokenBranches235[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc236, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc382(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 38; +} +x64Token x64Parser::tokenBranches381[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc382, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc235(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc381(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches234[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc235, x64Parser::tokenBranches235 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc381, x64Parser::tokenBranches381 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc64(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 8; +} +x64Token x64Parser::tokenBranches63[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc64, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches234 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc151(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 15; +} +x64Token x64Parser::tokenBranches150[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc151, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc297(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 30; +} +x64Token x64Parser::tokenBranches296[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc297, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc443(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 45; +} +x64Token x64Parser::tokenBranches442[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc443, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc63(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc150(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc296(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc442(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches62[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc63, x64Parser::tokenBranches63 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc150, x64Parser::tokenBranches150 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc296, x64Parser::tokenBranches296 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc442, x64Parser::tokenBranches442 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc107(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 15; +} +x64Token x64Parser::tokenBranches61[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches62 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc107, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc245(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 24; +} +x64Token x64Parser::tokenBranches244[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc245, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc391(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 39; +} +x64Token x64Parser::tokenBranches390[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc391, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc244(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc390(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches243[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc244, x64Parser::tokenBranches244 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc390, x64Parser::tokenBranches390 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc71(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 9; +} +x64Token x64Parser::tokenBranches70[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc71, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches243 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc177(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 18; +} +x64Token x64Parser::tokenBranches176[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc177, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc323(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 33; +} +x64Token x64Parser::tokenBranches322[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc323, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc469(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 48; +} +x64Token x64Parser::tokenBranches468[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc469, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc70(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc176(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc322(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc468(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches69[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc70, x64Parser::tokenBranches70 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc176, x64Parser::tokenBranches176 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc322, x64Parser::tokenBranches322 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc468, x64Parser::tokenBranches468 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc125(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 18; +} +x64Token x64Parser::tokenBranches68[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches69 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc125, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc271(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 27; +} +x64Token x64Parser::tokenBranches270[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc271, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc417(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 42; +} +x64Token x64Parser::tokenBranches416[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc417, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc270(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc416(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches269[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc270, x64Parser::tokenBranches270 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc416, x64Parser::tokenBranches416 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc89(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 12; +} +x64Token x64Parser::tokenBranches88[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc89, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches269 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 72; +} +x64Token x64Parser::tokenBranches729[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc854(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 86; +} +x64Token x64Parser::tokenBranches853[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc854, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 180; +} +x64Token x64Parser::tokenBranches2200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2201, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2760(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 206; +} +x64Token x64Parser::tokenBranches2759[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2760, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3058(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 232; +} +x64Token x64Parser::tokenBranches3057[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3058, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2200(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2759(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3057(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2199[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2200, x64Parser::tokenBranches2200 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2759, x64Parser::tokenBranches2759 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3057, x64Parser::tokenBranches3057 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2488(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 180; +} +x64Token x64Parser::tokenBranches2198[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2199 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2488, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2198(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2197[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2198, x64Parser::tokenBranches2198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2210(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 181; +} +x64Token x64Parser::tokenBranches2209[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2210, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2769(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 207; +} +x64Token x64Parser::tokenBranches2768[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2769, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3067(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 233; +} +x64Token x64Parser::tokenBranches3066[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3067, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2209(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2768(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3066(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2208[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2209, x64Parser::tokenBranches2209 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2768, x64Parser::tokenBranches2768 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3066, x64Parser::tokenBranches3066 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2495(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 181; +} +x64Token x64Parser::tokenBranches2196[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2197 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2208 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2495, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc729(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc853(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2196(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches728[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc729, x64Parser::tokenBranches729 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc853, x64Parser::tokenBranches853 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2196, x64Parser::tokenBranches2196 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc491(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 54; +} +x64Token x64Parser::tokenBranches490[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc491, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches728 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc737(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 73; +} +x64Token x64Parser::tokenBranches736[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc737, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc861(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 87; +} +x64Token x64Parser::tokenBranches860[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc861, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2181(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 178; +} +x64Token x64Parser::tokenBranches2180[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2181, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2740(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 204; +} +x64Token x64Parser::tokenBranches2739[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2740, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3038(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 230; +} +x64Token x64Parser::tokenBranches3037[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3038, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2180(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2739(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3037(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2179[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2180, x64Parser::tokenBranches2180 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2739, x64Parser::tokenBranches2739 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3037, x64Parser::tokenBranches3037 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 178; +} +x64Token x64Parser::tokenBranches2178[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2179 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2472, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2178(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2177[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2178, x64Parser::tokenBranches2178 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2190(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 179; +} +x64Token x64Parser::tokenBranches2189[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2190, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2749(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 205; +} +x64Token x64Parser::tokenBranches2748[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2749, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3047(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 231; +} +x64Token x64Parser::tokenBranches3046[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3047, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2189(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2748(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3046(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2188[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2189, x64Parser::tokenBranches2189 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2748, x64Parser::tokenBranches2748 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3046, x64Parser::tokenBranches3046 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2479(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 179; +} +x64Token x64Parser::tokenBranches2176[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2177 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2188 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2479, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2237(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 183; +} +x64Token x64Parser::tokenBranches2236[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2237, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2649(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 199; +} +x64Token x64Parser::tokenBranches2648[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2649, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3027(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 229; +} +x64Token x64Parser::tokenBranches3026[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3027, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2236(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2648(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3026(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2235[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2236, x64Parser::tokenBranches2236 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2648, x64Parser::tokenBranches2648 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3026, x64Parser::tokenBranches3026 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2463(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 183; +} +x64Token x64Parser::tokenBranches2234[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2235 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2463, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc736(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc860(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2176(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches735[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2234 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc736, x64Parser::tokenBranches736 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc860, x64Parser::tokenBranches860 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2176, x64Parser::tokenBranches2176 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1043(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 102; +} +x64Token x64Parser::tokenBranches1042[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1043, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1052(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 103; +} +x64Token x64Parser::tokenBranches1051[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1052, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1061(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 104; +} +x64Token x64Parser::tokenBranches1060[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1061, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1042(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1051(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1060(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1041[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1042, x64Parser::tokenBranches1042 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1051, x64Parser::tokenBranches1051 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1060, x64Parser::tokenBranches1060 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1034(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 102; +} +x64Token x64Parser::tokenBranches1033[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1034, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1041 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1171(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 111; +} +x64Token x64Parser::tokenBranches1170[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1171, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1180(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 112; +} +x64Token x64Parser::tokenBranches1179[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1180, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1189(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 113; +} +x64Token x64Parser::tokenBranches1188[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1189, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1170(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1179(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1188(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1169[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1170, x64Parser::tokenBranches1170 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1179, x64Parser::tokenBranches1179 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1188, x64Parser::tokenBranches1188 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1162(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 111; +} +x64Token x64Parser::tokenBranches1161[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1162, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1530(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 136; +} +x64Token x64Parser::tokenBranches1529[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1530, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1539(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 137; +} +x64Token x64Parser::tokenBranches1538[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1539, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1529(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1538(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1528[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1529, x64Parser::tokenBranches1529 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1538, x64Parser::tokenBranches1538 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1521(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 136; +} +x64Token x64Parser::tokenBranches1520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1521, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1528 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1033(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1161(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1520(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1032[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1033, x64Parser::tokenBranches1033 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1161, x64Parser::tokenBranches1161 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1520, x64Parser::tokenBranches1520 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc496(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 55; +} +x64Token x64Parser::tokenBranches495[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc496, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches735 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1032 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc637(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 56; +} +x64Token x64Parser::tokenBranches636[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc637, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc761(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 77; +} +x64Token x64Parser::tokenBranches760[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc761, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc885(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 91; +} +x64Token x64Parser::tokenBranches884[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc885, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2280(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 187; +} +x64Token x64Parser::tokenBranches2279[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2280, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2812(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 212; +} +x64Token x64Parser::tokenBranches2811[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2812, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 238; +} +x64Token x64Parser::tokenBranches3109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2279(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2811(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3109(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2278[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2279, x64Parser::tokenBranches2279 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2811, x64Parser::tokenBranches2811 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3109, x64Parser::tokenBranches3109 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2528(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 187; +} +x64Token x64Parser::tokenBranches2277[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2278 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2528, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2277(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2276[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2277, x64Parser::tokenBranches2277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2289(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 188; +} +x64Token x64Parser::tokenBranches2288[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2289, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2821(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 213; +} +x64Token x64Parser::tokenBranches2820[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2821, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3119(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 239; +} +x64Token x64Parser::tokenBranches3118[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3119, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2288(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2820(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3118(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2287[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2288, x64Parser::tokenBranches2288 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2820, x64Parser::tokenBranches2820 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3118, x64Parser::tokenBranches3118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2535(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 188; +} +x64Token x64Parser::tokenBranches2275[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2276 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2287 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2535, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc636(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc760(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc884(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2275(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches635[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc636, x64Parser::tokenBranches636 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc760, x64Parser::tokenBranches760 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc884, x64Parser::tokenBranches884 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2275, x64Parser::tokenBranches2275 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1299(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 120; +} +x64Token x64Parser::tokenBranches1298[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1299, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1308(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 121; +} +x64Token x64Parser::tokenBranches1307[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1308, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1317(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 122; +} +x64Token x64Parser::tokenBranches1316[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1317, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1298(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1307(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1316(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1297[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1298, x64Parser::tokenBranches1298 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1307, x64Parser::tokenBranches1307 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1316, x64Parser::tokenBranches1316 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 120; +} +x64Token x64Parser::tokenBranches1289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1290, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1427(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 129; +} +x64Token x64Parser::tokenBranches1426[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1427, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1436(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 130; +} +x64Token x64Parser::tokenBranches1435[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1436, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1445(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 131; +} +x64Token x64Parser::tokenBranches1444[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1445, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1426(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1435(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1444(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1425[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1426, x64Parser::tokenBranches1426 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1435, x64Parser::tokenBranches1435 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1444, x64Parser::tokenBranches1444 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1418(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 129; +} +x64Token x64Parser::tokenBranches1417[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1418, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1425 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1574(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 139; +} +x64Token x64Parser::tokenBranches1573[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1574, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1583(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 140; +} +x64Token x64Parser::tokenBranches1582[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1583, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1573(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1582(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1572[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1573, x64Parser::tokenBranches1573 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1582, x64Parser::tokenBranches1582 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1565(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 139; +} +x64Token x64Parser::tokenBranches1564[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1565, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1572 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1289(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1417(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1564(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1288[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1289, x64Parser::tokenBranches1289 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1417, x64Parser::tokenBranches1417 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1564, x64Parser::tokenBranches1564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc501(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 56; +} +x64Token x64Parser::tokenBranches500[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc501, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches635 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1288 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc685(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 62; +} +x64Token x64Parser::tokenBranches684[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc685, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc809(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 81; +} +x64Token x64Parser::tokenBranches808[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc809, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc926(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 94; +} +x64Token x64Parser::tokenBranches925[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc926, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc684(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc808(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc925(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches683[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc684, x64Parser::tokenBranches684 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc808, x64Parser::tokenBranches808 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc925, x64Parser::tokenBranches925 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc557(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 62; +} +x64Token x64Parser::tokenBranches556[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc557, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches683 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc676(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 61; +} +x64Token x64Parser::tokenBranches675[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc676, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc800(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 80; +} +x64Token x64Parser::tokenBranches799[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc800, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc933(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 95; +} +x64Token x64Parser::tokenBranches932[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc933, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2340(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 191; +} +x64Token x64Parser::tokenBranches2339[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2340, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2872(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 217; +} +x64Token x64Parser::tokenBranches2871[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2872, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3170(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 242; +} +x64Token x64Parser::tokenBranches3169[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3170, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2339(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2871(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3169(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2338[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2339, x64Parser::tokenBranches2339 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2871, x64Parser::tokenBranches2871 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3169, x64Parser::tokenBranches3169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2576(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 191; +} +x64Token x64Parser::tokenBranches2337[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2338 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2576, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2337(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2336[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2337, x64Parser::tokenBranches2337 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2349(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 192; +} +x64Token x64Parser::tokenBranches2348[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2349, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2881(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 218; +} +x64Token x64Parser::tokenBranches2880[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2881, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3179(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 243; +} +x64Token x64Parser::tokenBranches3178[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3179, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2348(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2880(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3178(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2347[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2348, x64Parser::tokenBranches2348 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2880, x64Parser::tokenBranches2880 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3178, x64Parser::tokenBranches3178 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2583(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 192; +} +x64Token x64Parser::tokenBranches2335[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2336 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2347 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2583, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc675(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc799(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc932(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2335(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches555[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches556 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc675, x64Parser::tokenBranches675 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc799, x64Parser::tokenBranches799 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc932, x64Parser::tokenBranches932 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2335, x64Parser::tokenBranches2335 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1693(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 144; +} +x64Token x64Parser::tokenBranches1692[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1693, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1702(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 145; +} +x64Token x64Parser::tokenBranches1701[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1702, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1711(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 146; +} +x64Token x64Parser::tokenBranches1710[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1711, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1692(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1701(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1710(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1691[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1692, x64Parser::tokenBranches1692 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1701, x64Parser::tokenBranches1701 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1710, x64Parser::tokenBranches1710 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1684(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 144; +} +x64Token x64Parser::tokenBranches1683[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1684, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1691 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1821(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 153; +} +x64Token x64Parser::tokenBranches1820[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1821, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1830(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 154; +} +x64Token x64Parser::tokenBranches1829[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1830, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1839(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 155; +} +x64Token x64Parser::tokenBranches1838[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1839, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1820(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1829(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1838(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1819[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1820, x64Parser::tokenBranches1820 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1829, x64Parser::tokenBranches1829 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1838, x64Parser::tokenBranches1838 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1812(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 153; +} +x64Token x64Parser::tokenBranches1811[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1812, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1819 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2011(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 165; +} +x64Token x64Parser::tokenBranches2010[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2011, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2020(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 166; +} +x64Token x64Parser::tokenBranches2019[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2020, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2040(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 167; +} +x64Token x64Parser::tokenBranches2039[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2040, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2051(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 168; +} +x64Token x64Parser::tokenBranches2050[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2051, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2039(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2050(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2038[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2039, x64Parser::tokenBranches2039 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2050, x64Parser::tokenBranches2050 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2029(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 167; +} +x64Token x64Parser::tokenBranches2028[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2029, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2038 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2010(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2019(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2009[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2028 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2010, x64Parser::tokenBranches2010 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2019, x64Parser::tokenBranches2019 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2002(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 165; +} +x64Token x64Parser::tokenBranches2001[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2002, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2009 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1683(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1811(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2001(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1682[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1683, x64Parser::tokenBranches1683 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1811, x64Parser::tokenBranches1811 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2001, x64Parser::tokenBranches2001 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc550(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 61; +} +x64Token x64Parser::tokenBranches549[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc550, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches555 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1682 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc575(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 66; +} +x64Token x64Parser::tokenBranches574[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc575, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3277(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 248; +} +x64Token x64Parser::tokenBranches3276[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3277, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3368(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 264; +} +x64Token x64Parser::tokenBranches3367[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3368, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3460(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 278; +} +x64Token x64Parser::tokenBranches3459[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3460, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4569(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 379; +} +x64Token x64Parser::tokenBranches4568[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4569, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4945(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 403; +} +x64Token x64Parser::tokenBranches4944[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4945, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5157(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 427; +} +x64Token x64Parser::tokenBranches5156[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5157, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4568(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4944(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5156(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4567[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4568, x64Parser::tokenBranches4568 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4944, x64Parser::tokenBranches4944 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5156, x64Parser::tokenBranches5156 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4755(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 379; +} +x64Token x64Parser::tokenBranches4566[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4567 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4755, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4566(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4565[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4566, x64Parser::tokenBranches4566 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4578(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 380; +} +x64Token x64Parser::tokenBranches4577[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4578, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4954(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 404; +} +x64Token x64Parser::tokenBranches4953[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4954, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5166(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 428; +} +x64Token x64Parser::tokenBranches5165[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5166, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4577(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4953(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5165(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4576[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4577, x64Parser::tokenBranches4577 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4953, x64Parser::tokenBranches4953 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5165, x64Parser::tokenBranches5165 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4762(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 380; +} +x64Token x64Parser::tokenBranches4564[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4565 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4576 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4762, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3276(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3367(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3459(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4564(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3275[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3276, x64Parser::tokenBranches3276 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3367, x64Parser::tokenBranches3367 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3459, x64Parser::tokenBranches3459 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4564, x64Parser::tokenBranches4564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3196(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 248; +} +x64Token x64Parser::tokenBranches3195[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3196, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3275 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3337(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 256; +} +x64Token x64Parser::tokenBranches3336[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3337, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 273; +} +x64Token x64Parser::tokenBranches3428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3521(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 287; +} +x64Token x64Parser::tokenBranches3520[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3521, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3336(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3428(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3520(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3335[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3336, x64Parser::tokenBranches3336 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3428, x64Parser::tokenBranches3428 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3520, x64Parser::tokenBranches3520 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3236(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 256; +} +x64Token x64Parser::tokenBranches3235[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3236, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3335 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3375(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 265; +} +x64Token x64Parser::tokenBranches3374[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3375, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3467(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 279; +} +x64Token x64Parser::tokenBranches3466[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3467, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4589(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 381; +} +x64Token x64Parser::tokenBranches4588[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4589, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4965(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 405; +} +x64Token x64Parser::tokenBranches4964[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4965, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5177(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 429; +} +x64Token x64Parser::tokenBranches5176[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5177, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4588(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4964(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5176(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4587[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4588, x64Parser::tokenBranches4588 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4964, x64Parser::tokenBranches4964 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5176, x64Parser::tokenBranches5176 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4771(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 381; +} +x64Token x64Parser::tokenBranches4586[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4587 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4771, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4586(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4585[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4586, x64Parser::tokenBranches4586 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4598(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 382; +} +x64Token x64Parser::tokenBranches4597[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4598, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4974(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 406; +} +x64Token x64Parser::tokenBranches4973[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4974, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5186(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 430; +} +x64Token x64Parser::tokenBranches5185[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5186, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4597(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4973(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5185(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4596[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4597, x64Parser::tokenBranches4597 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4973, x64Parser::tokenBranches4973 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5185, x64Parser::tokenBranches5185 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 382; +} +x64Token x64Parser::tokenBranches4584[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4585 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4596 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3374(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3466(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4584(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3234[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3235 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3374, x64Parser::tokenBranches3374 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3466, x64Parser::tokenBranches3466 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4584, x64Parser::tokenBranches4584 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3283(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 249; +} +x64Token x64Parser::tokenBranches3282[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3283, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3572(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 289; +} +x64Token x64Parser::tokenBranches3571[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3572, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3581(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 290; +} +x64Token x64Parser::tokenBranches3580[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3581, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3590(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 291; +} +x64Token x64Parser::tokenBranches3589[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3590, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3571(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3580(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3589(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3570[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3571, x64Parser::tokenBranches3571 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3580, x64Parser::tokenBranches3580 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3589, x64Parser::tokenBranches3589 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3563(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 289; +} +x64Token x64Parser::tokenBranches3562[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3563, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3570 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3632(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 295; +} +x64Token x64Parser::tokenBranches3631[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3632, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3641(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 296; +} +x64Token x64Parser::tokenBranches3640[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3641, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 297; +} +x64Token x64Parser::tokenBranches3649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3650, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3631(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3640(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3649(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3630[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3631, x64Parser::tokenBranches3631 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3640, x64Parser::tokenBranches3640 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3649, x64Parser::tokenBranches3649 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 295; +} +x64Token x64Parser::tokenBranches3622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3623, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3630 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3678(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 301; +} +x64Token x64Parser::tokenBranches3677[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3678, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3677(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3676[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3677, x64Parser::tokenBranches3677 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3669(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 300; +} +x64Token x64Parser::tokenBranches3668[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3669, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3676 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3706(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 305; +} +x64Token x64Parser::tokenBranches3705[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3706, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3705(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3704[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3705, x64Parser::tokenBranches3705 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3697(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 304; +} +x64Token x64Parser::tokenBranches3696[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3697, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3704 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3562(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3622(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3668(x64Operand &operand, int tokenPos) +{ + operand.values[13] = new Coding[2]; + CleanupValues.push_back(operand.values[13]); + operand.values[13]->type = Coding::number; + operand.values[13]->val = operands.size(); + operand.values[13]->bits = 0; + operand.values[13]->field = 0; + operand.values[13]->unary = 0; + operand.values[13]->binary = 0; + operand.values[13][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3696(x64Operand &operand, int tokenPos) +{ + operand.values[14] = new Coding[2]; + CleanupValues.push_back(operand.values[14]); + operand.values[14]->type = Coding::number; + operand.values[14]->val = operands.size(); + operand.values[14]->bits = 0; + operand.values[14]->field = 0; + operand.values[14]->unary = 0; + operand.values[14]->binary = 0; + operand.values[14][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3561[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3562, x64Parser::tokenBranches3562 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3622, x64Parser::tokenBranches3622 }, + {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3668, x64Parser::tokenBranches3668 }, + {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3696, x64Parser::tokenBranches3696 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 249; +} +void x64Parser::TokenFunc3282(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3201, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3234 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3282, x64Parser::tokenBranches3282 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3561 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3290(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 250; +} +x64Token x64Parser::tokenBranches3289[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3290, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3382(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 266; +} +x64Token x64Parser::tokenBranches3381[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3382, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3474(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 280; +} +x64Token x64Parser::tokenBranches3473[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3474, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4481(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 369; +} +x64Token x64Parser::tokenBranches4480[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4481, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4857(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 393; +} +x64Token x64Parser::tokenBranches4856[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4857, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5069(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 417; +} +x64Token x64Parser::tokenBranches5068[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5069, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4480(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4856(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5068(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4479[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4480, x64Parser::tokenBranches4480 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4856, x64Parser::tokenBranches4856 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5068, x64Parser::tokenBranches5068 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4687(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 369; +} +x64Token x64Parser::tokenBranches4478[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4479 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4687, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4549(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 377; +} +x64Token x64Parser::tokenBranches4548[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4549, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4925(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 401; +} +x64Token x64Parser::tokenBranches4924[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4925, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5137(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 425; +} +x64Token x64Parser::tokenBranches5136[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5137, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4548(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4924(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5136(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4547[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4548, x64Parser::tokenBranches4548 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4924, x64Parser::tokenBranches4924 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5136, x64Parser::tokenBranches5136 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4739(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 377; +} +x64Token x64Parser::tokenBranches4546[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4547 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4739, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4546(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4545[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4546, x64Parser::tokenBranches4546 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4558(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 378; +} +x64Token x64Parser::tokenBranches4557[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4558, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4934(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 402; +} +x64Token x64Parser::tokenBranches4933[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4934, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5146(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 426; +} +x64Token x64Parser::tokenBranches5145[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4557(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4933(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5145(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4556[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4557, x64Parser::tokenBranches4557 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4933, x64Parser::tokenBranches4933 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5145, x64Parser::tokenBranches5145 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4746(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 378; +} +x64Token x64Parser::tokenBranches4544[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4545 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4556 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4746, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3289(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3381(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3473(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4544(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3288[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4478 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3289, x64Parser::tokenBranches3289 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3381, x64Parser::tokenBranches3381 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3473, x64Parser::tokenBranches3473 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4544, x64Parser::tokenBranches4544 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3816(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 312; +} +x64Token x64Parser::tokenBranches3815[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3816, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3825(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 313; +} +x64Token x64Parser::tokenBranches3824[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3825, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3834(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 314; +} +x64Token x64Parser::tokenBranches3833[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3834, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3815(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3824(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3833(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3814[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3815, x64Parser::tokenBranches3815 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3824, x64Parser::tokenBranches3824 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3833, x64Parser::tokenBranches3833 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3807(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 312; +} +x64Token x64Parser::tokenBranches3806[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3807, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3814 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3944(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 321; +} +x64Token x64Parser::tokenBranches3943[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3944, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3953(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 322; +} +x64Token x64Parser::tokenBranches3952[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3953, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3962(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 323; +} +x64Token x64Parser::tokenBranches3961[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3962, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3943(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3952(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3961(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3942[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3943, x64Parser::tokenBranches3943 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3952, x64Parser::tokenBranches3952 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3961, x64Parser::tokenBranches3961 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3935(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 321; +} +x64Token x64Parser::tokenBranches3934[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3935, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3942 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4246(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 345; +} +x64Token x64Parser::tokenBranches4245[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4245(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4244[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4245, x64Parser::tokenBranches4245 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4237(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 344; +} +x64Token x64Parser::tokenBranches4236[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4237, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4244 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3806(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3934(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4236(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3805[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3806, x64Parser::tokenBranches3806 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3934, x64Parser::tokenBranches3934 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4236, x64Parser::tokenBranches4236 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3206(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 250; +} +x64Token x64Parser::tokenBranches3205[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3206, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3288 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3805 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3321(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 251; +} +x64Token x64Parser::tokenBranches3320[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3321, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3413(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 271; +} +x64Token x64Parser::tokenBranches3412[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3413, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3505(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 285; +} +x64Token x64Parser::tokenBranches3504[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3505, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4490(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 370; +} +x64Token x64Parser::tokenBranches4489[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4490, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4866(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 394; +} +x64Token x64Parser::tokenBranches4865[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4866, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5078(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 418; +} +x64Token x64Parser::tokenBranches5077[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5078, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4489(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4865(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5077(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4488[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4489, x64Parser::tokenBranches4489 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4865, x64Parser::tokenBranches4865 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5077, x64Parser::tokenBranches5077 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4694(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 370; +} +x64Token x64Parser::tokenBranches4487[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4488 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4694, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4641(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 387; +} +x64Token x64Parser::tokenBranches4640[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4641, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5017(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 411; +} +x64Token x64Parser::tokenBranches5016[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5017, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5229(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 435; +} +x64Token x64Parser::tokenBranches5228[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5229, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4640(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5016(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5228(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4639[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4640, x64Parser::tokenBranches4640 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5016, x64Parser::tokenBranches5016 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5228, x64Parser::tokenBranches5228 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4811(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 387; +} +x64Token x64Parser::tokenBranches4638[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4639 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4811, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4638(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4637[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4638, x64Parser::tokenBranches4638 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4650(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 388; +} +x64Token x64Parser::tokenBranches4649[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4650, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5026(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 412; +} +x64Token x64Parser::tokenBranches5025[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5026, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5238(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 436; +} +x64Token x64Parser::tokenBranches5237[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5238, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4649(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5025(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5237(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4648[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4649, x64Parser::tokenBranches4649 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5025, x64Parser::tokenBranches5025 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5237, x64Parser::tokenBranches5237 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4818(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 388; +} +x64Token x64Parser::tokenBranches4636[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4637 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4648 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4818, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3320(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3412(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3504(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4636(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3319[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4487 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3320, x64Parser::tokenBranches3320 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3412, x64Parser::tokenBranches3412 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3504, x64Parser::tokenBranches3504 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4636, x64Parser::tokenBranches4636 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4072(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 330; +} +x64Token x64Parser::tokenBranches4071[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4072, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4081(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 331; +} +x64Token x64Parser::tokenBranches4080[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4081, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4090(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 332; +} +x64Token x64Parser::tokenBranches4089[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4090, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4071(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4080(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4089(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4070[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4071, x64Parser::tokenBranches4071 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4080, x64Parser::tokenBranches4080 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4089, x64Parser::tokenBranches4089 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4063(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 330; +} +x64Token x64Parser::tokenBranches4062[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4063, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4070 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4200(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 339; +} +x64Token x64Parser::tokenBranches4199[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4200, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4209(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 340; +} +x64Token x64Parser::tokenBranches4208[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4209, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 341; +} +x64Token x64Parser::tokenBranches4217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4199(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4208(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4217(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4198[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4199, x64Parser::tokenBranches4199 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4208, x64Parser::tokenBranches4208 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4217, x64Parser::tokenBranches4217 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 339; +} +x64Token x64Parser::tokenBranches4190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4191, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4198 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4274(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 349; +} +x64Token x64Parser::tokenBranches4273[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4274, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4273(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4272[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4273, x64Parser::tokenBranches4273 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 348; +} +x64Token x64Parser::tokenBranches4264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4265, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4272 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4062(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4190(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4264(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4061[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4062, x64Parser::tokenBranches4062 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4190, x64Parser::tokenBranches4190 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4264, x64Parser::tokenBranches4264 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3211(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 251; +} +x64Token x64Parser::tokenBranches3210[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3211, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3319 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4061 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 257; +} +x64Token x64Parser::tokenBranches3345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3438(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 274; +} +x64Token x64Parser::tokenBranches3437[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3438, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3530(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 288; +} +x64Token x64Parser::tokenBranches3529[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3530, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3345(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3437(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3529(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3344[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3345, x64Parser::tokenBranches3345 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3437, x64Parser::tokenBranches3437 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3529, x64Parser::tokenBranches3529 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3243(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 257; +} +x64Token x64Parser::tokenBranches3242[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3243, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3344 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3328(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 255; +} +x64Token x64Parser::tokenBranches3327[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3328, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3420(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 272; +} +x64Token x64Parser::tokenBranches3419[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3420, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3512(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 286; +} +x64Token x64Parser::tokenBranches3511[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3512, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4661(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 389; +} +x64Token x64Parser::tokenBranches4660[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4661, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5037(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 413; +} +x64Token x64Parser::tokenBranches5036[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5037, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5249(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 437; +} +x64Token x64Parser::tokenBranches5248[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5249, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4660(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5036(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5248(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4659[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4660, x64Parser::tokenBranches4660 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5036, x64Parser::tokenBranches5036 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5248, x64Parser::tokenBranches5248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4827(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 389; +} +x64Token x64Parser::tokenBranches4658[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4659 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4827, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4658(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4657[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4658, x64Parser::tokenBranches4658 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4670(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 390; +} +x64Token x64Parser::tokenBranches4669[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4670, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5046(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 414; +} +x64Token x64Parser::tokenBranches5045[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5046, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5258(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 438; +} +x64Token x64Parser::tokenBranches5257[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5258, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4669(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5045(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5257(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4668[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4669, x64Parser::tokenBranches4669 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5045, x64Parser::tokenBranches5045 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5257, x64Parser::tokenBranches5257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4834(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 390; +} +x64Token x64Parser::tokenBranches4656[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4657 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4668 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4834, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3327(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3419(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3511(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4656(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3241[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3242 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3327, x64Parser::tokenBranches3327 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3419, x64Parser::tokenBranches3419 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3511, x64Parser::tokenBranches3511 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4656, x64Parser::tokenBranches4656 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4316(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 350; +} +x64Token x64Parser::tokenBranches4315[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4316, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4325(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 351; +} +x64Token x64Parser::tokenBranches4324[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4325, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4334(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 352; +} +x64Token x64Parser::tokenBranches4333[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4334, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4315(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4324(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4333(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4314[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4315, x64Parser::tokenBranches4315 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4324, x64Parser::tokenBranches4324 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4333, x64Parser::tokenBranches4333 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4307(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 350; +} +x64Token x64Parser::tokenBranches4306[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4307, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4314 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4376(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 356; +} +x64Token x64Parser::tokenBranches4375[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4376, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4385(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 357; +} +x64Token x64Parser::tokenBranches4384[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4385, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4394(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 358; +} +x64Token x64Parser::tokenBranches4393[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4394, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4375(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4384(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4393(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4374[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4375, x64Parser::tokenBranches4375 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4384, x64Parser::tokenBranches4384 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4393, x64Parser::tokenBranches4393 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4367(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 356; +} +x64Token x64Parser::tokenBranches4366[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4367, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4374 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4438(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 364; +} +x64Token x64Parser::tokenBranches4437[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4438, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4458(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 366; +} +x64Token x64Parser::tokenBranches4457[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4458, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4457(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4456[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4457, x64Parser::tokenBranches4457 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4447(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 365; +} +x64Token x64Parser::tokenBranches4446[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4447, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4456 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4437(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4436[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4446 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4437, x64Parser::tokenBranches4437 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4429(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 363; +} +x64Token x64Parser::tokenBranches4428[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4429, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4436 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4306(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4366(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4428(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4305[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4306, x64Parser::tokenBranches4306 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4366, x64Parser::tokenBranches4366 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4428, x64Parser::tokenBranches4428 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3229(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 255; +} +x64Token x64Parser::tokenBranches3228[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3229, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3241 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3256(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 260; +} +x64Token x64Parser::tokenBranches3255[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3256, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc18(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc88(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc549(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc574(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3228(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc3255(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches17[] = { + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches61 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches68 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches490 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches495 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches500 }, + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3195 }, + {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3200 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3205 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3210 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc18, x64Parser::tokenBranches18 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc88, x64Parser::tokenBranches88 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc549, x64Parser::tokenBranches549 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc574, x64Parser::tokenBranches574 }, + {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3228, x64Parser::tokenBranches3228 }, + {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3255, x64Parser::tokenBranches3255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches16[] = { + {x64Token::TOKEN, 3, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches17 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc184(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 19; +} +x64Token x64Parser::tokenBranches183[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc184, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc330(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 34; +} +x64Token x64Parser::tokenBranches329[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc330, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc183(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc329(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches182[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc183, x64Parser::tokenBranches183 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc329, x64Parser::tokenBranches329 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc24(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 4; +} +x64Token x64Parser::tokenBranches23[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc24, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches182 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc130(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches129[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc130, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc276(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 28; +} +x64Token x64Parser::tokenBranches275[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc276, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc422(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 43; +} +x64Token x64Parser::tokenBranches421[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc422, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc23(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc129(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc275(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc421(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches22[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc23, x64Parser::tokenBranches23 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc129, x64Parser::tokenBranches129 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc275, x64Parser::tokenBranches275 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc421, x64Parser::tokenBranches421 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc92(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 13; +} +x64Token x64Parser::tokenBranches21[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches22 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc92, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 20; +} +x64Token x64Parser::tokenBranches190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc191, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc337(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 35; +} +x64Token x64Parser::tokenBranches336[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc337, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc190(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc336(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches189[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc190, x64Parser::tokenBranches190 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc336, x64Parser::tokenBranches336 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc29(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 5; +} +x64Token x64Parser::tokenBranches28[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc29, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches189 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc156(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches155[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc156, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc302(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 31; +} +x64Token x64Parser::tokenBranches301[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc302, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc448(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 46; +} +x64Token x64Parser::tokenBranches447[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc448, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc28(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc155(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc301(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc447(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches27[] = { + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc28, x64Parser::tokenBranches28 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc155, x64Parser::tokenBranches155 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc301, x64Parser::tokenBranches301 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc447, x64Parser::tokenBranches447 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 16; +} +x64Token x64Parser::tokenBranches26[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches27 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc250(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 25; +} +x64Token x64Parser::tokenBranches249[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc250, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc396(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 40; +} +x64Token x64Parser::tokenBranches395[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc396, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc249(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc395(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches248[] = { + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc249, x64Parser::tokenBranches249 }, + {x64Token::NUMBER, 4, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc395, x64Parser::tokenBranches395 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc74(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 10; +} +x64Token x64Parser::tokenBranches73[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc74, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches248 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc580(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; +} +x64Token x64Parser::tokenBranches579[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc580, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc690(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 68; +} +x64Token x64Parser::tokenBranches689[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc690, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc814(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 82; +} +x64Token x64Parser::tokenBranches813[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc814, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2083(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; +} +x64Token x64Parser::tokenBranches2082[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2083, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2615(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 196; +} +x64Token x64Parser::tokenBranches2614[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2615, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2913(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 222; +} +x64Token x64Parser::tokenBranches2912[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2913, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2082(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2614(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2912(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2081[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2082, x64Parser::tokenBranches2082 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2614, x64Parser::tokenBranches2614 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2912, x64Parser::tokenBranches2912 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2373(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 172; +} +x64Token x64Parser::tokenBranches2080[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2081 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2373, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2080(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2079[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2080, x64Parser::tokenBranches2080 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2090(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2089[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2090, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2622(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 197; +} +x64Token x64Parser::tokenBranches2621[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2622, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2920(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 223; +} +x64Token x64Parser::tokenBranches2919[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2920, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2089(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2621(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2919(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2088[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2089, x64Parser::tokenBranches2089 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2621, x64Parser::tokenBranches2621 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2919, x64Parser::tokenBranches2919 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2378(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 173; +} +x64Token x64Parser::tokenBranches2078[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2079 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2088 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2378, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc579(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc689(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc813(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2078(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches578[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc579, x64Parser::tokenBranches579 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc689, x64Parser::tokenBranches689 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc813, x64Parser::tokenBranches813 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2078, x64Parser::tokenBranches2078 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 49; +} +x64Token x64Parser::tokenBranches471[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc472, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches578 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc585(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; +} +x64Token x64Parser::tokenBranches584[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc585, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc695(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 69; +} +x64Token x64Parser::tokenBranches694[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc695, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc819(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 83; +} +x64Token x64Parser::tokenBranches818[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc819, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2058(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2057[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2058, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2590(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 193; +} +x64Token x64Parser::tokenBranches2589[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2590, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2888(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 219; +} +x64Token x64Parser::tokenBranches2887[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2888, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2057(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2589(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2887(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2056[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2057, x64Parser::tokenBranches2057 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2589, x64Parser::tokenBranches2589 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2887, x64Parser::tokenBranches2887 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2354(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 169; +} +x64Token x64Parser::tokenBranches2055[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2056 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2354, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2067(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2066[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2067, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2599(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 194; +} +x64Token x64Parser::tokenBranches2598[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2599, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2897(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 220; +} +x64Token x64Parser::tokenBranches2896[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2897, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2066(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2598(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2896(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2065[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2066, x64Parser::tokenBranches2066 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2598, x64Parser::tokenBranches2598 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2896, x64Parser::tokenBranches2896 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2361(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2064[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2065 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2361, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2064(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2063[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2064, x64Parser::tokenBranches2064 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2074(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; +} +x64Token x64Parser::tokenBranches2073[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2074, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2606(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 195; +} +x64Token x64Parser::tokenBranches2605[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2606, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2904(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 221; +} +x64Token x64Parser::tokenBranches2903[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2904, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2073(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2605(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2903(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2072[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2073, x64Parser::tokenBranches2073 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2605, x64Parser::tokenBranches2605 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2903, x64Parser::tokenBranches2903 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2366(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 171; +} +x64Token x64Parser::tokenBranches2062[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2063 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2072 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2366, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc584(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc694(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc818(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2062(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches583[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2055 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc584, x64Parser::tokenBranches584 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc694, x64Parser::tokenBranches694 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc818, x64Parser::tokenBranches818 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2062, x64Parser::tokenBranches2062 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc945(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches944[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc945, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc952(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 97; +} +x64Token x64Parser::tokenBranches951[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc952, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc959(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 98; +} +x64Token x64Parser::tokenBranches958[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc959, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc944(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc951(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc958(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches943[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc944, x64Parser::tokenBranches944 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc951, x64Parser::tokenBranches951 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc958, x64Parser::tokenBranches958 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc938(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 96; +} +x64Token x64Parser::tokenBranches937[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc938, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches943 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1073(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; +} +x64Token x64Parser::tokenBranches1072[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1073, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1080(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 106; +} +x64Token x64Parser::tokenBranches1079[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1080, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1087(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 107; +} +x64Token x64Parser::tokenBranches1086[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1087, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1072(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1079(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1086(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1071[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1072, x64Parser::tokenBranches1072 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1079, x64Parser::tokenBranches1079 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1086, x64Parser::tokenBranches1086 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1066(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 105; +} +x64Token x64Parser::tokenBranches1065[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1066, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1071 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1457(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1456[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1457, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1464(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; +} +x64Token x64Parser::tokenBranches1463[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1464, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1456(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1463(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1455[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1456, x64Parser::tokenBranches1456 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1463, x64Parser::tokenBranches1463 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1450(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 132; +} +x64Token x64Parser::tokenBranches1449[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1450, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1455 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc937(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1065(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1449(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches936[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc937, x64Parser::tokenBranches937 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1065, x64Parser::tokenBranches1065 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1449, x64Parser::tokenBranches1449 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc475(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 50; +} +x64Token x64Parser::tokenBranches474[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc475, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches583 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches936 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc618(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 51; +} +x64Token x64Parser::tokenBranches617[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc618, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc742(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 74; +} +x64Token x64Parser::tokenBranches741[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc742, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc866(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 88; +} +x64Token x64Parser::tokenBranches865[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc866, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2246(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2245[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2778(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 208; +} +x64Token x64Parser::tokenBranches2777[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3076(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 234; +} +x64Token x64Parser::tokenBranches3075[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3076, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2245(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2777(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3075(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2244[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2245, x64Parser::tokenBranches2245 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2777, x64Parser::tokenBranches2777 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3075, x64Parser::tokenBranches3075 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2502(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 170; +} +x64Token x64Parser::tokenBranches2243[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2244 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2502, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2243(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2242[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2243, x64Parser::tokenBranches2243 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2253(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 184; +} +x64Token x64Parser::tokenBranches2252[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2253, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2785(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 209; +} +x64Token x64Parser::tokenBranches2784[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2785, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3083(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 235; +} +x64Token x64Parser::tokenBranches3082[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3083, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2252(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2784(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3082(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2251[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2252, x64Parser::tokenBranches2252 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2784, x64Parser::tokenBranches2784 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3082, x64Parser::tokenBranches3082 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2507(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 184; +} +x64Token x64Parser::tokenBranches2241[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2242 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2251 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2507, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc617(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc741(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc865(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2241(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches616[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc617, x64Parser::tokenBranches617 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc741, x64Parser::tokenBranches741 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc865, x64Parser::tokenBranches865 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2241, x64Parser::tokenBranches2241 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1201(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1200[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1201, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1208(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 115; +} +x64Token x64Parser::tokenBranches1207[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1208, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1215(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 116; +} +x64Token x64Parser::tokenBranches1214[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1215, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1200(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1207(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1214(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1199[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1200, x64Parser::tokenBranches1200 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1207, x64Parser::tokenBranches1207 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1214, x64Parser::tokenBranches1214 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1194(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 114; +} +x64Token x64Parser::tokenBranches1193[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1194, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1199 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1329(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1328[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1329, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1336(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 124; +} +x64Token x64Parser::tokenBranches1335[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1336, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1343(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 125; +} +x64Token x64Parser::tokenBranches1342[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1343, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1328(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1335(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1342(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1327[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1328, x64Parser::tokenBranches1328 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1335, x64Parser::tokenBranches1335 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1342, x64Parser::tokenBranches1342 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1322(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 123; +} +x64Token x64Parser::tokenBranches1321[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1322, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1327 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1551(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 138; +} +x64Token x64Parser::tokenBranches1550[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1558(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 133; +} +x64Token x64Parser::tokenBranches1557[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1558, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1550(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1557(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1549[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1550, x64Parser::tokenBranches1550 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1557, x64Parser::tokenBranches1557 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1544(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 138; +} +x64Token x64Parser::tokenBranches1543[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1544, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1549 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1193(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1321(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1543(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1192[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1193, x64Parser::tokenBranches1193 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1321, x64Parser::tokenBranches1321 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1543, x64Parser::tokenBranches1543 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc478(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 51; +} +x64Token x64Parser::tokenBranches477[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc478, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches616 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1192 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc630(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; +} +x64Token x64Parser::tokenBranches629[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc630, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc754(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 76; +} +x64Token x64Parser::tokenBranches753[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc754, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc878(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 90; +} +x64Token x64Parser::tokenBranches877[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc878, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc629(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc753(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc877(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches628[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc629, x64Parser::tokenBranches629 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc753, x64Parser::tokenBranches753 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc877, x64Parser::tokenBranches877 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc486(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 53; +} +x64Token x64Parser::tokenBranches485[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc486, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches628 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc623, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc747(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches746[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc747, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc871(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches870[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc871, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2262(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; +} +x64Token x64Parser::tokenBranches2261[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2262, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2794(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 210; +} +x64Token x64Parser::tokenBranches2793[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2794, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3092(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 236; +} +x64Token x64Parser::tokenBranches3091[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3092, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2261(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2793(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3091(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2260[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2261, x64Parser::tokenBranches2261 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2793, x64Parser::tokenBranches2793 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3091, x64Parser::tokenBranches3091 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2514(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 185; +} +x64Token x64Parser::tokenBranches2259[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2260 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2514, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2259(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2258[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2259, x64Parser::tokenBranches2259 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2269(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2268[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2269, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2801(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 211; +} +x64Token x64Parser::tokenBranches2800[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2801, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3099(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 237; +} +x64Token x64Parser::tokenBranches3098[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3099, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2268(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2800(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3098(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2267[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2268, x64Parser::tokenBranches2268 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2800, x64Parser::tokenBranches2800 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3098, x64Parser::tokenBranches3098 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc2519(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 186; +} +x64Token x64Parser::tokenBranches2257[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2258 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches2267 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2519, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc622(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc746(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc870(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc2257(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches484[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches485 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc622, x64Parser::tokenBranches622 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc746, x64Parser::tokenBranches746 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc870, x64Parser::tokenBranches870 }, + {x64Token::REGISTERCLASS, 6, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc2257, x64Parser::tokenBranches2257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1595(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1594[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1595, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1602(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 75; +} +x64Token x64Parser::tokenBranches1601[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1602, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1609(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 89; +} +x64Token x64Parser::tokenBranches1608[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1609, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1594(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1601(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1608(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1593[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1594, x64Parser::tokenBranches1594 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1601, x64Parser::tokenBranches1601 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1608, x64Parser::tokenBranches1608 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1588(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches1587[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1588, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1593 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1723(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; +} +x64Token x64Parser::tokenBranches1722[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1723, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 148; +} +x64Token x64Parser::tokenBranches1729[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1737(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 149; +} +x64Token x64Parser::tokenBranches1736[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1737, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1722(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1729(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1736(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1721[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1722, x64Parser::tokenBranches1722 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1729, x64Parser::tokenBranches1729 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1736, x64Parser::tokenBranches1736 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1716(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 147; +} +x64Token x64Parser::tokenBranches1715[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1716, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1721 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1851(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1850[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1851, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1858(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 157; +} +x64Token x64Parser::tokenBranches1857[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1858, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1874(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1873[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1874, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1883(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 159; +} +x64Token x64Parser::tokenBranches1882[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1883, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1873(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1882(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1872[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1873, x64Parser::tokenBranches1873 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1882, x64Parser::tokenBranches1882 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1865(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 158; +} +x64Token x64Parser::tokenBranches1864[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1865, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1872 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1850(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1857(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1849[] = { + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1864 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1850, x64Parser::tokenBranches1850 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1857, x64Parser::tokenBranches1857 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1844(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 156; +} +x64Token x64Parser::tokenBranches1843[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1844, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1849 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc1587(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1715(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc1843(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches1586[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1587, x64Parser::tokenBranches1587 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1715, x64Parser::tokenBranches1715 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc1843, x64Parser::tokenBranches1843 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc481(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 52; +} +x64Token x64Parser::tokenBranches480[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc481, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches484 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches1586 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc560(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 63; +} +x64Token x64Parser::tokenBranches559[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc560, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3261(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 244; +} +x64Token x64Parser::tokenBranches3260[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3261, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3351(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 261; +} +x64Token x64Parser::tokenBranches3350[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3351, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3443(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 275; +} +x64Token x64Parser::tokenBranches3442[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3443, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4515(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 373; +} +x64Token x64Parser::tokenBranches4514[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4515, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4891(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 397; +} +x64Token x64Parser::tokenBranches4890[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4891, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5103(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 421; +} +x64Token x64Parser::tokenBranches5102[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5103, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4514(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4890(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5102(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4513[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4514, x64Parser::tokenBranches4514 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4890, x64Parser::tokenBranches4890 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5102, x64Parser::tokenBranches5102 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4713(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 373; +} +x64Token x64Parser::tokenBranches4512[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4513 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4713, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4512(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4511[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4512, x64Parser::tokenBranches4512 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4522(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 374; +} +x64Token x64Parser::tokenBranches4521[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4522, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4898(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 398; +} +x64Token x64Parser::tokenBranches4897[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4898, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5110(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 422; +} +x64Token x64Parser::tokenBranches5109[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5110, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4521(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4897(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5109(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4520[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4521, x64Parser::tokenBranches4521 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4897, x64Parser::tokenBranches4897 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5109, x64Parser::tokenBranches5109 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4718(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 374; +} +x64Token x64Parser::tokenBranches4510[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4511 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4520 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4718, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3260(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3350(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3442(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4510(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3259[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3260, x64Parser::tokenBranches3260 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3350, x64Parser::tokenBranches3350 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3442, x64Parser::tokenBranches3442 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4510, x64Parser::tokenBranches4510 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3182(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 244; +} +x64Token x64Parser::tokenBranches3181[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3182, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3259 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3307(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 253; +} +x64Token x64Parser::tokenBranches3306[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3307, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3399(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 269; +} +x64Token x64Parser::tokenBranches3398[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3399, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3491(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 283; +} +x64Token x64Parser::tokenBranches3490[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3491, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3306(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3398(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3490(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3305[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3306, x64Parser::tokenBranches3306 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3398, x64Parser::tokenBranches3398 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3490, x64Parser::tokenBranches3490 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3219(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 253; +} +x64Token x64Parser::tokenBranches3218[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3219, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3356(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 262; +} +x64Token x64Parser::tokenBranches3355[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3356, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3448(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 276; +} +x64Token x64Parser::tokenBranches3447[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3448, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4531(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 375; +} +x64Token x64Parser::tokenBranches4530[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4531, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4907(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 399; +} +x64Token x64Parser::tokenBranches4906[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4907, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5119(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 423; +} +x64Token x64Parser::tokenBranches5118[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5119, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4530(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4906(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5118(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4529[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4530, x64Parser::tokenBranches4530 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4906, x64Parser::tokenBranches4906 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5118, x64Parser::tokenBranches5118 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4725(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 375; +} +x64Token x64Parser::tokenBranches4528[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4529 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4725, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4528(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4527[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4528, x64Parser::tokenBranches4528 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4538(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 376; +} +x64Token x64Parser::tokenBranches4537[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4538, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4914(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 400; +} +x64Token x64Parser::tokenBranches4913[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4914, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5126(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 424; +} +x64Token x64Parser::tokenBranches5125[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5126, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4537(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4913(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5125(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4536[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4537, x64Parser::tokenBranches4537 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4913, x64Parser::tokenBranches4913 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5125, x64Parser::tokenBranches5125 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4730(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 376; +} +x64Token x64Parser::tokenBranches4526[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4527 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4536 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4730, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3355(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3447(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4526(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3217[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3218 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3355, x64Parser::tokenBranches3355 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3447, x64Parser::tokenBranches3447 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4526, x64Parser::tokenBranches4526 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3264[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3265, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3542(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3541[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3542, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3549(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 262; +} +x64Token x64Parser::tokenBranches3548[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3549, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3556(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 276; +} +x64Token x64Parser::tokenBranches3555[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3556, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3541(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3548(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3555(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3540[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3541, x64Parser::tokenBranches3541 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3548, x64Parser::tokenBranches3548 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3555, x64Parser::tokenBranches3555 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3535(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +x64Token x64Parser::tokenBranches3534[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3535, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3540 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3602(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 292; +} +x64Token x64Parser::tokenBranches3601[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3602, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3609(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 293; +} +x64Token x64Parser::tokenBranches3608[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3609, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3616(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 294; +} +x64Token x64Parser::tokenBranches3615[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3616, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3601(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3608(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3615(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3600[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3601, x64Parser::tokenBranches3601 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3608, x64Parser::tokenBranches3608 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3615, x64Parser::tokenBranches3615 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3595(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 292; +} +x64Token x64Parser::tokenBranches3594[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3595, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3600 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3662(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 299; +} +x64Token x64Parser::tokenBranches3661[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3662, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3661(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3660[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3661, x64Parser::tokenBranches3661 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3655(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 298; +} +x64Token x64Parser::tokenBranches3654[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3655, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3660 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3690(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 303; +} +x64Token x64Parser::tokenBranches3689[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3690, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3689(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3688[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3689, x64Parser::tokenBranches3689 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3683(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 302; +} +x64Token x64Parser::tokenBranches3682[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3683, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3688 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3534(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3594(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3654(x64Operand &operand, int tokenPos) +{ + operand.values[13] = new Coding[2]; + CleanupValues.push_back(operand.values[13]); + operand.values[13]->type = Coding::number; + operand.values[13]->val = operands.size(); + operand.values[13]->bits = 0; + operand.values[13]->field = 0; + operand.values[13]->unary = 0; + operand.values[13]->binary = 0; + operand.values[13][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3682(x64Operand &operand, int tokenPos) +{ + operand.values[14] = new Coding[2]; + CleanupValues.push_back(operand.values[14]); + operand.values[14]->type = Coding::number; + operand.values[14]->val = operands.size(); + operand.values[14]->bits = 0; + operand.values[14]->field = 0; + operand.values[14]->unary = 0; + operand.values[14]->binary = 0; + operand.values[14][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3533[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3534, x64Parser::tokenBranches3534 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3594, x64Parser::tokenBranches3594 }, + {x64Token::NUMBER, 20, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3654, x64Parser::tokenBranches3654 }, + {x64Token::NUMBER, 21, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3682, x64Parser::tokenBranches3682 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3185(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 245; +} +void x64Parser::TokenFunc3264(x64Operand &operand, int tokenPos) +{ + operand.values[12] = new Coding[2]; + CleanupValues.push_back(operand.values[12]); + operand.values[12]->type = Coding::number; + operand.values[12]->val = operands.size(); + operand.values[12]->bits = 0; + operand.values[12]->field = 0; + operand.values[12]->unary = 0; + operand.values[12]->binary = 0; + operand.values[12][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3184[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3185, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3217 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3264, x64Parser::tokenBranches3264 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3533 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3270(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 246; +} +x64Token x64Parser::tokenBranches3269[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3270, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3361(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 263; +} +x64Token x64Parser::tokenBranches3360[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3361, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3453(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 277; +} +x64Token x64Parser::tokenBranches3452[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3453, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4465(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 367; +} +x64Token x64Parser::tokenBranches4464[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4465, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4841(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 391; +} +x64Token x64Parser::tokenBranches4840[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4841, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5053(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 415; +} +x64Token x64Parser::tokenBranches5052[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5053, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4464(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4840(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5052(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4463[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4464, x64Parser::tokenBranches4464 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4840, x64Parser::tokenBranches4840 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5052, x64Parser::tokenBranches5052 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4675(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 367; +} +x64Token x64Parser::tokenBranches4462[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4463 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4675, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4499(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 371; +} +x64Token x64Parser::tokenBranches4498[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4499, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4875(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 395; +} +x64Token x64Parser::tokenBranches4874[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4875, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5087(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 419; +} +x64Token x64Parser::tokenBranches5086[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5087, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4498(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4874(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5086(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4497[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4498, x64Parser::tokenBranches4498 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4874, x64Parser::tokenBranches4874 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5086, x64Parser::tokenBranches5086 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4701(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 371; +} +x64Token x64Parser::tokenBranches4496[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4497 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4701, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4496(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4495[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4496, x64Parser::tokenBranches4496 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4506(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 372; +} +x64Token x64Parser::tokenBranches4505[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4506, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4882(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 396; +} +x64Token x64Parser::tokenBranches4881[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4882, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5094(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 420; +} +x64Token x64Parser::tokenBranches5093[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5094, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4505(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4881(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5093(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4504[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4505, x64Parser::tokenBranches4505 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4881, x64Parser::tokenBranches4881 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5093, x64Parser::tokenBranches5093 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4706(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 372; +} +x64Token x64Parser::tokenBranches4494[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4495 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4504 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4706, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3269(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3360(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3452(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4494(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3268[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4462 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3269, x64Parser::tokenBranches3269 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3360, x64Parser::tokenBranches3360 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3452, x64Parser::tokenBranches3452 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4494, x64Parser::tokenBranches4494 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3718(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3717[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3718, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3725(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 307; +} +x64Token x64Parser::tokenBranches3724[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3725, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3732(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 308; +} +x64Token x64Parser::tokenBranches3731[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3732, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3717(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3724(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3731(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3716[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3717, x64Parser::tokenBranches3717 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3724, x64Parser::tokenBranches3724 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3731, x64Parser::tokenBranches3731 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3711(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 306; +} +x64Token x64Parser::tokenBranches3710[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3711, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3716 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3846(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3845[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3846, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3853(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 316; +} +x64Token x64Parser::tokenBranches3852[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3853, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3860(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 317; +} +x64Token x64Parser::tokenBranches3859[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3860, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3845(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3852(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3859(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3844[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3845, x64Parser::tokenBranches3845 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3852, x64Parser::tokenBranches3852 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3859, x64Parser::tokenBranches3859 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3839(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 315; +} +x64Token x64Parser::tokenBranches3838[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3839, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3844 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4230(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 343; +} +x64Token x64Parser::tokenBranches4229[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4230, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4229(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4228[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4229, x64Parser::tokenBranches4229 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4223(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 342; +} +x64Token x64Parser::tokenBranches4222[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4223, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4228 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3710(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3838(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4222(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3709[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3710, x64Parser::tokenBranches3710 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3838, x64Parser::tokenBranches3838 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4222, x64Parser::tokenBranches4222 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3188(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 246; +} +x64Token x64Parser::tokenBranches3187[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3188, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3268 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3709 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3295(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 247; +} +x64Token x64Parser::tokenBranches3294[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3295, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3387(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 267; +} +x64Token x64Parser::tokenBranches3386[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3479(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 281; +} +x64Token x64Parser::tokenBranches3478[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3479, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4472(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 368; +} +x64Token x64Parser::tokenBranches4471[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4472, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4848(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 392; +} +x64Token x64Parser::tokenBranches4847[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4848, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5060(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 416; +} +x64Token x64Parser::tokenBranches5059[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5060, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4471(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4847(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5059(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4470[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4471, x64Parser::tokenBranches4471 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4847, x64Parser::tokenBranches4847 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5059, x64Parser::tokenBranches5059 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4680(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 368; +} +x64Token x64Parser::tokenBranches4469[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4470 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4680, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4607(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 383; +} +x64Token x64Parser::tokenBranches4606[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4607, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4983(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 407; +} +x64Token x64Parser::tokenBranches4982[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4983, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5195(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 431; +} +x64Token x64Parser::tokenBranches5194[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5195, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4606(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4982(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5194(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4605[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4606, x64Parser::tokenBranches4606 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4982, x64Parser::tokenBranches4982 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5194, x64Parser::tokenBranches5194 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4785(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 383; +} +x64Token x64Parser::tokenBranches4604[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4605 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4785, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4604(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4603[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4604, x64Parser::tokenBranches4604 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4614(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 384; +} +x64Token x64Parser::tokenBranches4613[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4614, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4990(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 408; +} +x64Token x64Parser::tokenBranches4989[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4990, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5202(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 432; +} +x64Token x64Parser::tokenBranches5201[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5202, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4613(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4989(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5201(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4612[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4613, x64Parser::tokenBranches4613 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4989, x64Parser::tokenBranches4989 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5201, x64Parser::tokenBranches5201 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4790(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 384; +} +x64Token x64Parser::tokenBranches4602[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4603 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4612 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4790, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3294(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3386(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3478(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4602(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3293[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4469 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3294, x64Parser::tokenBranches3294 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3386, x64Parser::tokenBranches3386 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3478, x64Parser::tokenBranches3478 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4602, x64Parser::tokenBranches4602 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3974(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches3973[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3974, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3981(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 325; +} +x64Token x64Parser::tokenBranches3980[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3981, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3988(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 326; +} +x64Token x64Parser::tokenBranches3987[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3988, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3973(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3980(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3987(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3972[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3973, x64Parser::tokenBranches3973 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3980, x64Parser::tokenBranches3980 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3987, x64Parser::tokenBranches3987 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3967(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 324; +} +x64Token x64Parser::tokenBranches3966[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3967, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3972 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4102(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4101[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4102, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4109(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 334; +} +x64Token x64Parser::tokenBranches4108[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4109, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4116(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 335; +} +x64Token x64Parser::tokenBranches4115[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4116, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4101(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4108(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4115(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4100[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4101, x64Parser::tokenBranches4101 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4108, x64Parser::tokenBranches4108 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4115, x64Parser::tokenBranches4115 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4095(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 333; +} +x64Token x64Parser::tokenBranches4094[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4095, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4100 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4258(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 347; +} +x64Token x64Parser::tokenBranches4257[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4258, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4257(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4256[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4257, x64Parser::tokenBranches4257 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4251(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 346; +} +x64Token x64Parser::tokenBranches4250[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4251, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4256 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3966(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4094(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4250(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3965[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3966, x64Parser::tokenBranches3966 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4094, x64Parser::tokenBranches4094 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4250, x64Parser::tokenBranches4250 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3191(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 247; +} +x64Token x64Parser::tokenBranches3190[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3191, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3293 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3965 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3314(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 254; +} +x64Token x64Parser::tokenBranches3313[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3314, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3406(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 270; +} +x64Token x64Parser::tokenBranches3405[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3406, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3498(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 284; +} +x64Token x64Parser::tokenBranches3497[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3498, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3313(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3405(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3497(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3312[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3313, x64Parser::tokenBranches3313 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3405, x64Parser::tokenBranches3405 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3497, x64Parser::tokenBranches3497 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3224(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 254; +} +x64Token x64Parser::tokenBranches3223[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3224, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3312 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches3299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3392(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 268; +} +x64Token x64Parser::tokenBranches3391[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3392, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3484(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 282; +} +x64Token x64Parser::tokenBranches3483[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3484, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4623(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 385; +} +x64Token x64Parser::tokenBranches4622[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4623, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4999(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 409; +} +x64Token x64Parser::tokenBranches4998[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4999, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5211(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 433; +} +x64Token x64Parser::tokenBranches5210[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5211, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4622(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4998(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5210(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4621[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4622, x64Parser::tokenBranches4622 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4998, x64Parser::tokenBranches4998 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5210, x64Parser::tokenBranches5210 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4797(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 385; +} +x64Token x64Parser::tokenBranches4620[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4621 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4797, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4620(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4619[] = { + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4620, x64Parser::tokenBranches4620 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4630(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 386; +} +x64Token x64Parser::tokenBranches4629[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4630, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5006(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 410; +} +x64Token x64Parser::tokenBranches5005[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5006, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5218(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 434; +} +x64Token x64Parser::tokenBranches5217[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5218, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4629(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5005(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5217(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4628[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4629, x64Parser::tokenBranches4629 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5005, x64Parser::tokenBranches5005 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc5217, x64Parser::tokenBranches5217 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4802(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 386; +} +x64Token x64Parser::tokenBranches4618[] = { + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4619 }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4628 }, + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4802, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3299(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3391(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3483(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4618(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches3222[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3223 }, + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3299, x64Parser::tokenBranches3299 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3391, x64Parser::tokenBranches3391 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3483, x64Parser::tokenBranches3483 }, + {x64Token::REGISTERCLASS, 9, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4618, x64Parser::tokenBranches4618 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4286(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches4285[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4286, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4293(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 268; +} +x64Token x64Parser::tokenBranches4292[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4293, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4300(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 282; +} +x64Token x64Parser::tokenBranches4299[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4300, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4285(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4292(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4299(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4284[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4285, x64Parser::tokenBranches4285 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4292, x64Parser::tokenBranches4292 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4299, x64Parser::tokenBranches4299 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4279(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches4278[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4279, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4284 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4346(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 353; +} +x64Token x64Parser::tokenBranches4345[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4346, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4353(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 354; +} +x64Token x64Parser::tokenBranches4352[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4353, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4360(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 355; +} +x64Token x64Parser::tokenBranches4359[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4360, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4345(x64Operand &operand, int tokenPos) +{ + operand.values[4] = new Coding[2]; + CleanupValues.push_back(operand.values[4]); + operand.values[4]->type = Coding::number; + operand.values[4]->val = operands.size(); + operand.values[4]->bits = 0; + operand.values[4]->field = 0; + operand.values[4]->unary = 0; + operand.values[4]->binary = 0; + operand.values[4][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4352(x64Operand &operand, int tokenPos) +{ + operand.values[5] = new Coding[2]; + CleanupValues.push_back(operand.values[5]); + operand.values[5]->type = Coding::number; + operand.values[5]->val = operands.size(); + operand.values[5]->bits = 0; + operand.values[5]->field = 0; + operand.values[5]->unary = 0; + operand.values[5]->binary = 0; + operand.values[5][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4359(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4344[] = { + {x64Token::NUMBER, 17, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4345, x64Parser::tokenBranches4345 }, + {x64Token::NUMBER, 0, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4352, x64Parser::tokenBranches4352 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4359, x64Parser::tokenBranches4359 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4339(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 353; +} +x64Token x64Parser::tokenBranches4338[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4339, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4344 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4406(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 360; +} +x64Token x64Parser::tokenBranches4405[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4406, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4422(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 362; +} +x64Token x64Parser::tokenBranches4421[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4422, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4421(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4420[] = { + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4421, x64Parser::tokenBranches4421 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4413(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 361; +} +x64Token x64Parser::tokenBranches4412[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4413, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4420 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4405(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4404[] = { + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4412 }, + {x64Token::NUMBER, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4405, x64Parser::tokenBranches4405 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4399(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 359; +} +x64Token x64Parser::tokenBranches4398[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4399, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4404 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc4278(x64Operand &operand, int tokenPos) +{ + operand.values[7] = new Coding[2]; + CleanupValues.push_back(operand.values[7]); + operand.values[7]->type = Coding::number; + operand.values[7]->val = operands.size(); + operand.values[7]->bits = 0; + operand.values[7]->field = 0; + operand.values[7]->unary = 0; + operand.values[7]->binary = 0; + operand.values[7][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4338(x64Operand &operand, int tokenPos) +{ + operand.values[8] = new Coding[2]; + CleanupValues.push_back(operand.values[8]); + operand.values[8]->type = Coding::number; + operand.values[8]->val = operands.size(); + operand.values[8]->bits = 0; + operand.values[8]->field = 0; + operand.values[8]->unary = 0; + operand.values[8]->binary = 0; + operand.values[8][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc4398(x64Operand &operand, int tokenPos) +{ + operand.values[9] = new Coding[2]; + CleanupValues.push_back(operand.values[9]); + operand.values[9]->type = Coding::number; + operand.values[9]->val = operands.size(); + operand.values[9]->bits = 0; + operand.values[9]->field = 0; + operand.values[9]->unary = 0; + operand.values[9]->binary = 0; + operand.values[9][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches4277[] = { + {x64Token::NUMBER, 18, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4278, x64Parser::tokenBranches4278 }, + {x64Token::NUMBER, 19, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4338, x64Parser::tokenBranches4338 }, + {x64Token::NUMBER, 16, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc4398, x64Parser::tokenBranches4398 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3214(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 252; +} +x64Token x64Parser::tokenBranches3213[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3214, }, + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3222 }, + {x64Token::TOKEN, 5, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches4277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3248(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 258; +} +x64Token x64Parser::tokenBranches3247[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3248, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3247(x64Operand &operand, int tokenPos) +{ + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches3246[] = { + {x64Token::NUMBER, 15, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3247, x64Parser::tokenBranches3247 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches3245[] = { + {x64Token::TOKEN, 4, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3246 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3251(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 259; +} +x64Token x64Parser::tokenBranches3250[] = { + {x64Token::TOKEN, 2, 1, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3251, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc3(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc16(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc73(x64Operand &operand, int tokenPos) +{ + operand.values[3] = new Coding[2]; + CleanupValues.push_back(operand.values[3]); + operand.values[3]->type = Coding::reg; + operand.values[3]->val = inputTokens[tokenPos]->val->ival; + operand.values[3]->bits = 0; + operand.values[3]->field = 0; + operand.values[3]->unary = 0; + operand.values[3]->binary = 0; + operand.values[3][1].type = Coding::eot; +} +void x64Parser::TokenFunc480(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc559(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc3213(x64Operand &operand, int tokenPos) +{ + operand.values[6] = new Coding[2]; + CleanupValues.push_back(operand.values[6]); + operand.values[6]->type = Coding::reg; + operand.values[6]->val = inputTokens[tokenPos]->val->ival; + operand.values[6]->bits = 0; + operand.values[6]->field = 0; + operand.values[6]->unary = 0; + operand.values[6]->binary = 0; + operand.values[6][1].type = Coding::eot; +} +void x64Parser::TokenFunc3250(x64Operand &operand, int tokenPos) +{ + operand.values[1] = new Coding[2]; + CleanupValues.push_back(operand.values[1]); + operand.values[1]->type = Coding::number; + operand.values[1]->val = operands.size(); + operand.values[1]->bits = 0; + operand.values[1]->field = 0; + operand.values[1]->unary = 0; + operand.values[1]->binary = 0; + operand.values[1][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches2[] = { + {x64Token::REGISTER, 96, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches6 }, + {x64Token::REGISTER, 95, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches11 }, + {x64Token::REGISTER, 29, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches21 }, + {x64Token::REGISTER, 45, 0, 0, x64Parser::RegClassData2, NULL, x64Parser::tokenBranches26 }, + {x64Token::REGISTER, 38, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches471 }, + {x64Token::REGISTER, 46, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches474 }, + {x64Token::REGISTER, 50, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches477 }, + {x64Token::REGISTER, 39, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3181 }, + {x64Token::REGISTER, 43, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3184 }, + {x64Token::REGISTER, 47, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3187 }, + {x64Token::REGISTER, 51, 0, 0, x64Parser::RegClassData3, NULL, x64Parser::tokenBranches3190 }, + {x64Token::REGISTER, 68, 0, 0, x64Parser::RegClassData5, NULL, x64Parser::tokenBranches3245 }, + {x64Token::NUMBER, 6, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc3, x64Parser::tokenBranches3 }, + {x64Token::REGISTERCLASS, 19, 0, 0, x64Parser::RegClassData1, &x64Parser::TokenFunc16, x64Parser::tokenBranches16 }, + {x64Token::REGISTERCLASS, 15, 0, 0, x64Parser::RegClassData2, &x64Parser::TokenFunc73, x64Parser::tokenBranches73 }, + {x64Token::REGISTERCLASS, 5, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc480, x64Parser::tokenBranches480 }, + {x64Token::NUMBER, 7, 0, 0, x64Parser::RegClassData4, &x64Parser::TokenFunc559, x64Parser::tokenBranches559 }, + {x64Token::REGISTERCLASS, 8, 0, 0, x64Parser::RegClassData3, &x64Parser::TokenFunc3213, x64Parser::tokenBranches3213 }, + {x64Token::NUMBER, 8, 0, 0, x64Parser::RegClassData5, &x64Parser::TokenFunc3250, x64Parser::tokenBranches3250 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5259(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 439; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5260(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5261(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 441; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5262(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5263(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5264(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5265(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 442; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5266(x64Operand &operand, int tokenPos) +{ + operand.addressCoding = 440; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches1[] = { + {x64Token::TOKEN, 1, 0, 0, x64Parser::RegClassData1, NULL, x64Parser::tokenBranches2 }, + {x64Token::REGISTERCLASS, 20, 1, 0, x64Parser::RegClassData6, &x64Parser::TokenFunc5259, }, + {x64Token::REGISTERCLASS, 1, 1, 0, x64Parser::RegClassData7, &x64Parser::TokenFunc5260, }, + {x64Token::REGISTERCLASS, 14, 1, 0, x64Parser::RegClassData8, &x64Parser::TokenFunc5261, }, + {x64Token::REGISTERCLASS, 4, 1, 0, x64Parser::RegClassData9, &x64Parser::TokenFunc5262, }, + {x64Token::REGISTERCLASS, 7, 1, 0, x64Parser::RegClassData10, &x64Parser::TokenFunc5263, }, + {x64Token::REGISTERCLASS, 10, 1, 0, x64Parser::RegClassData11, &x64Parser::TokenFunc5264, }, + {x64Token::REGISTERCLASS, 18, 1, 0, x64Parser::RegClassData12, &x64Parser::TokenFunc5265, }, + {x64Token::REGISTERCLASS, 17, 1, 0, x64Parser::RegClassData13, &x64Parser::TokenFunc5266, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5268(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 443; +} +x64Token x64Parser::tokenBranches5267[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5268, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5270(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 444; +} +x64Token x64Parser::tokenBranches5269[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5270, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5275_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5275_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5275(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5275_16; + operand.values[17] = tokenCoding5275_17; + operand.values[18] = tokenCoding5275_18; + operand.values[19] = tokenCoding5275_19; +} +Coding x64Parser::tokenCoding5287_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5287_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5287(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5287_16; + operand.values[17] = tokenCoding5287_17; + operand.values[18] = tokenCoding5287_18; + operand.values[19] = tokenCoding5287_19; +} +x64Token x64Parser::tokenBranches5274[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5275, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5287, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5273[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5272[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5273 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5279_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5279_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5279(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5279_16; + operand.values[17] = tokenCoding5279_17; + operand.values[18] = tokenCoding5279_18; + operand.values[19] = tokenCoding5279_19; +} +Coding x64Parser::tokenCoding5291_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5291_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5291(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5291_16; + operand.values[17] = tokenCoding5291_17; + operand.values[18] = tokenCoding5291_18; + operand.values[19] = tokenCoding5291_19; +} +x64Token x64Parser::tokenBranches5278[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5279, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5291, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5277[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5276[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5277 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5283_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5283_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5283(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5283_16; + operand.values[17] = tokenCoding5283_17; + operand.values[18] = tokenCoding5283_18; + operand.values[19] = tokenCoding5283_19; +} +Coding x64Parser::tokenCoding5295_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5295_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5295(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5295_16; + operand.values[17] = tokenCoding5295_17; + operand.values[18] = tokenCoding5295_18; + operand.values[19] = tokenCoding5295_19; +} +x64Token x64Parser::tokenBranches5282[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5283, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5295, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5281[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5280[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5281 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5272(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5276(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5280(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5271[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5272, x64Parser::tokenBranches5272 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5276, x64Parser::tokenBranches5276 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5280, x64Parser::tokenBranches5280 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5300_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding5300_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5300_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5300_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5300(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5300_16; + operand.values[17] = tokenCoding5300_17; + operand.values[18] = tokenCoding5300_18; + operand.values[19] = tokenCoding5300_19; +} +x64Token x64Parser::tokenBranches5299[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5300, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5298[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5299 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5298 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5304_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5304_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5304(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5304_16; + operand.values[17] = tokenCoding5304_17; + operand.values[18] = tokenCoding5304_18; + operand.values[19] = tokenCoding5304_19; +} +x64Token x64Parser::tokenBranches5303[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5304, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5302[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5303 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5301[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5302 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5308_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5308_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5308(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5308_16; + operand.values[17] = tokenCoding5308_17; + operand.values[18] = tokenCoding5308_18; + operand.values[19] = tokenCoding5308_19; +} +x64Token x64Parser::tokenBranches5307[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5308, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5306[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5307 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5306 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5297(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5301(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5305(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5296[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5297, x64Parser::tokenBranches5297 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5301, x64Parser::tokenBranches5301 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5305, x64Parser::tokenBranches5305 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5313(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 445; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5312[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5313, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5311[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5312 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5310[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5311 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5317(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 446; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5316[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5317, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5315[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5316 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5321(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 447; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5320[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5321, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5319[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5320 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5318[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5319 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5325(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 448; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5324[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5325, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5323[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5324 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5322[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5323 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5329_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5329_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5329(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5329_16; + operand.values[17] = tokenCoding5329_17; + operand.values[18] = tokenCoding5329_18; + operand.values[19] = tokenCoding5329_19; +} +x64Token x64Parser::tokenBranches5328[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5329, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5327[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5328 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5327 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5333_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5333_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5333(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5333_16; + operand.values[17] = tokenCoding5333_17; + operand.values[23] = tokenCoding5333_23; + operand.values[18] = tokenCoding5333_18; + operand.values[19] = tokenCoding5333_19; +} +x64Token x64Parser::tokenBranches5332[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5333, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5331[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5332 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5330[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5331 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5337_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5337_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5337(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5337_16; + operand.values[17] = tokenCoding5337_17; + operand.values[18] = tokenCoding5337_18; + operand.values[19] = tokenCoding5337_19; +} +x64Token x64Parser::tokenBranches5336[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5337, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5335[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5336 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5334[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5335 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5341_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5341_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5341(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5341_16; + operand.values[17] = tokenCoding5341_17; + operand.values[18] = tokenCoding5341_18; + operand.values[19] = tokenCoding5341_19; +} +x64Token x64Parser::tokenBranches5340[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5341, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5339[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5340 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5338[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5339 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5345_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5345_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5345(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5345_16; + operand.values[17] = tokenCoding5345_17; + operand.values[18] = tokenCoding5345_18; + operand.values[19] = tokenCoding5345_19; +} +x64Token x64Parser::tokenBranches5344[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5345, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5343[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5344 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5342[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5343 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5349_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5349_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5349(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5349_16; + operand.values[17] = tokenCoding5349_17; + operand.values[18] = tokenCoding5349_18; + operand.values[19] = tokenCoding5349_19; +} +Coding x64Parser::tokenCoding5353_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5353_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5353(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5353_16; + operand.values[17] = tokenCoding5353_17; + operand.values[23] = tokenCoding5353_23; + operand.values[18] = tokenCoding5353_18; + operand.values[19] = tokenCoding5353_19; +} +x64Token x64Parser::tokenBranches5348[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5349, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5353, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5347[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5348 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5346[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5347 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5357_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5357_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5357(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5357_16; + operand.values[17] = tokenCoding5357_17; + operand.values[18] = tokenCoding5357_18; + operand.values[19] = tokenCoding5357_19; +} +x64Token x64Parser::tokenBranches5356[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5357, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5355[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5356 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5354[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5355 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5361_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5361_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5361(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5361_16; + operand.values[17] = tokenCoding5361_17; + operand.values[18] = tokenCoding5361_18; + operand.values[19] = tokenCoding5361_19; +} +x64Token x64Parser::tokenBranches5360[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5361, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5359[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5360 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5358[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5359 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5365_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5365_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5365(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5365_16; + operand.values[17] = tokenCoding5365_17; + operand.values[18] = tokenCoding5365_18; + operand.values[19] = tokenCoding5365_19; +} +x64Token x64Parser::tokenBranches5364[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5365, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5363[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5364 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5362[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5363 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5370_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5370_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5370_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5370(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5370_16; + operand.values[17] = tokenCoding5370_17; + operand.values[19] = tokenCoding5370_19; +} +x64Token x64Parser::tokenBranches5369[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5370, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5368[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5369 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5367[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5368 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5366[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5367 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5375_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5375_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5375_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5375(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5375_16; + operand.values[17] = tokenCoding5375_17; + operand.values[19] = tokenCoding5375_19; +} +x64Token x64Parser::tokenBranches5374[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5375, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5380_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5380_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5380_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5380(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5380_16; + operand.values[17] = tokenCoding5380_17; + operand.values[19] = tokenCoding5380_19; +} +Coding x64Parser::tokenCoding5385_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5385_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5385_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5385(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 451; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5385_16; + operand.values[17] = tokenCoding5385_17; + operand.values[19] = tokenCoding5385_19; +} +x64Token x64Parser::tokenBranches5379[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5380, }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5385, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5373[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5374 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5379 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5372[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5373 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5371[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5372 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5390_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5390_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5390_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5390(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5390_16; + operand.values[17] = tokenCoding5390_17; + operand.values[19] = tokenCoding5390_19; +} +x64Token x64Parser::tokenBranches5389[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5390, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5395_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5395_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5395_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5395(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5395_16; + operand.values[17] = tokenCoding5395_17; + operand.values[19] = tokenCoding5395_19; +} +x64Token x64Parser::tokenBranches5394[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5395, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5400_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5400_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5400_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5400(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5400_16; + operand.values[17] = tokenCoding5400_17; + operand.values[19] = tokenCoding5400_19; +} +Coding x64Parser::tokenCoding5405_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5405_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5405_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5405(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5405_16; + operand.values[17] = tokenCoding5405_17; + operand.values[19] = tokenCoding5405_19; +} +x64Token x64Parser::tokenBranches5399[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5400, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5405, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5388[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5389 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5394 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5399 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5387[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5388 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5386[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5387 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5410_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5410_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5410_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5410(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5410_16; + operand.values[17] = tokenCoding5410_17; + operand.values[19] = tokenCoding5410_19; +} +x64Token x64Parser::tokenBranches5409[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5410, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5415_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5415_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5415_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5415(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5415_16; + operand.values[17] = tokenCoding5415_17; + operand.values[19] = tokenCoding5415_19; +} +x64Token x64Parser::tokenBranches5414[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5415, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5420_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5420_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5420_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5420(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5420_16; + operand.values[17] = tokenCoding5420_17; + operand.values[19] = tokenCoding5420_19; +} +x64Token x64Parser::tokenBranches5419[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5420, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5425_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5425_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5425_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5425(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5425_16; + operand.values[17] = tokenCoding5425_17; + operand.values[19] = tokenCoding5425_19; +} +Coding x64Parser::tokenCoding5430_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5430_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5430_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5430(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5430_16; + operand.values[17] = tokenCoding5430_17; + operand.values[19] = tokenCoding5430_19; +} +x64Token x64Parser::tokenBranches5424[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5425, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5430, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5408[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5409 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5414 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5419 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5424 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5407[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5408 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5406[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5407 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5434_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5434_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5434_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5434(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5434_16; + operand.values[17] = tokenCoding5434_17; + operand.values[19] = tokenCoding5434_19; +} +x64Token x64Parser::tokenBranches5433[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5434, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5432[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5433 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5431[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5432 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5438_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5438_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5438_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5438(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5438_16; + operand.values[17] = tokenCoding5438_17; + operand.values[19] = tokenCoding5438_19; +} +x64Token x64Parser::tokenBranches5437[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5438, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5442_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5442_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5442_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5442(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 450; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5442_16; + operand.values[17] = tokenCoding5442_17; + operand.values[19] = tokenCoding5442_19; +} +Coding x64Parser::tokenCoding5446_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5446_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5446_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5446(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 451; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5446_16; + operand.values[17] = tokenCoding5446_17; + operand.values[19] = tokenCoding5446_19; +} +x64Token x64Parser::tokenBranches5441[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5442, }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc5446, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5436[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5437 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5441 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5435[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5436 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5450_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5450_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5450_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5450(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5450_16; + operand.values[17] = tokenCoding5450_17; + operand.values[19] = tokenCoding5450_19; +} +x64Token x64Parser::tokenBranches5449[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5450, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5454_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5454_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5454_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5454(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5454_16; + operand.values[17] = tokenCoding5454_17; + operand.values[19] = tokenCoding5454_19; +} +x64Token x64Parser::tokenBranches5453[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5454, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5458_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5458_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5458_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5458(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 452; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5458_16; + operand.values[17] = tokenCoding5458_17; + operand.values[19] = tokenCoding5458_19; +} +Coding x64Parser::tokenCoding5462_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5462_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5462_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5462(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 453; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5462_16; + operand.values[17] = tokenCoding5462_17; + operand.values[19] = tokenCoding5462_19; +} +x64Token x64Parser::tokenBranches5457[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5458, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5462, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5448[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5449 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5453 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5457 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5447[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5448 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5466_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5466_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5466_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5466(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5466_16; + operand.values[17] = tokenCoding5466_17; + operand.values[19] = tokenCoding5466_19; +} +x64Token x64Parser::tokenBranches5465[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5466, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5470_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5470_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5470_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5470(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5470_16; + operand.values[17] = tokenCoding5470_17; + operand.values[19] = tokenCoding5470_19; +} +x64Token x64Parser::tokenBranches5469[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5470, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5474_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5474_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5474_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5474(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5474_16; + operand.values[17] = tokenCoding5474_17; + operand.values[19] = tokenCoding5474_19; +} +x64Token x64Parser::tokenBranches5473[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5474, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5478_16[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5478_17[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5478_19[] = { + { CODING_NAME("signedimm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5478(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 454; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5478_16; + operand.values[17] = tokenCoding5478_17; + operand.values[19] = tokenCoding5478_19; +} +Coding x64Parser::tokenCoding5482_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5482_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5482_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5482(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 455; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5482_16; + operand.values[17] = tokenCoding5482_17; + operand.values[19] = tokenCoding5482_19; +} +x64Token x64Parser::tokenBranches5477[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc5478, }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc5482, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5464[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5465 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5469 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5473 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5477 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5463[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5464 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5326(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5330(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5334(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5338(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5342(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5309[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches5310 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5314 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5318 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5322 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc5326, x64Parser::tokenBranches5326 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc5330, x64Parser::tokenBranches5330 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5334, x64Parser::tokenBranches5334 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5338, x64Parser::tokenBranches5338 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5342, x64Parser::tokenBranches5342 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5346 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5354 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5358 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5362 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5366 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5371 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5386 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5406 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5431 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5435 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5447 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5463 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5488_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5488_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5488_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5488(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 456; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5488_16; + operand.values[17] = tokenCoding5488_17; + operand.values[19] = tokenCoding5488_19; +} +x64Token x64Parser::tokenBranches5487[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5488, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5502_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5502_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5502(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5502_16; + operand.values[17] = tokenCoding5502_17; + operand.values[18] = tokenCoding5502_18; + operand.values[19] = tokenCoding5502_19; +} +x64Token x64Parser::tokenBranches5486[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5487 }, + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5502, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5485[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5486 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5484[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5485 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5493_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5493_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5493_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5493(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 457; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5493_16; + operand.values[17] = tokenCoding5493_17; + operand.values[19] = tokenCoding5493_19; +} +x64Token x64Parser::tokenBranches5492[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5493, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5506_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5506_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5506(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5506_16; + operand.values[17] = tokenCoding5506_17; + operand.values[18] = tokenCoding5506_18; + operand.values[19] = tokenCoding5506_19; +} +x64Token x64Parser::tokenBranches5491[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5492 }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5506, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5490[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5491 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5489[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5490 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5498_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5498_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5498_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5498(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 458; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5498_16; + operand.values[17] = tokenCoding5498_17; + operand.values[19] = tokenCoding5498_19; +} +x64Token x64Parser::tokenBranches5497[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5498, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5510_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5510_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5510(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5510_16; + operand.values[17] = tokenCoding5510_17; + operand.values[18] = tokenCoding5510_18; + operand.values[19] = tokenCoding5510_19; +} +x64Token x64Parser::tokenBranches5496[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5497 }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5510, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5495[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5496 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5494[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5495 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5483[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5484 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5489 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5494 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5520_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5520_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5520_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5520(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5520_16; + operand.values[17] = tokenCoding5520_17; + operand.values[19] = tokenCoding5520_19; +} +x64Token x64Parser::tokenBranches5519[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5520, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5522_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5522_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5522_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5522(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5522_16; + operand.values[17] = tokenCoding5522_17; + operand.values[19] = tokenCoding5522_19; +} +x64Token x64Parser::tokenBranches5521[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5522, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5524_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5524_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5524_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5524(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5524_16; + operand.values[17] = tokenCoding5524_17; + operand.values[19] = tokenCoding5524_19; +} +x64Token x64Parser::tokenBranches5523[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5524, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5526_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5526_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5526_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5526(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5526_16; + operand.values[17] = tokenCoding5526_17; + operand.values[19] = tokenCoding5526_19; +} +x64Token x64Parser::tokenBranches5525[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5526, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5512_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5512_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5512_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5512(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5512_16; + operand.values[17] = tokenCoding5512_17; + operand.values[19] = tokenCoding5512_19; +} +void x64Parser::TokenFunc5513(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 459; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5514(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 460; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5515(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 461; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +Coding x64Parser::tokenCoding5516_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5516_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5516_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5516(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5516_16; + operand.values[17] = tokenCoding5516_17; + operand.values[19] = tokenCoding5516_19; +} +Coding x64Parser::tokenCoding5517_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5517_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5517_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5517(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5517_16; + operand.values[17] = tokenCoding5517_17; + operand.values[19] = tokenCoding5517_19; +} +Coding x64Parser::tokenCoding5518_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5518_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5518_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5518(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5518_16; + operand.values[17] = tokenCoding5518_17; + operand.values[19] = tokenCoding5518_19; +} +x64Token x64Parser::tokenBranches5511[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5512, }, + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5513, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5514, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5515, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5516, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5517, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5518, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5519 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5521 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5523 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5525 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5533_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5533_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5533_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5533(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5533_16; + operand.values[17] = tokenCoding5533_17; + operand.values[19] = tokenCoding5533_19; +} +x64Token x64Parser::tokenBranches5532[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5533, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5535_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5535_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5535_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5535(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5535_16; + operand.values[17] = tokenCoding5535_17; + operand.values[19] = tokenCoding5535_19; +} +x64Token x64Parser::tokenBranches5534[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5535, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5537_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5537_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5537_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5537(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5537_16; + operand.values[17] = tokenCoding5537_17; + operand.values[19] = tokenCoding5537_19; +} +x64Token x64Parser::tokenBranches5536[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5537, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5539_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5539_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5539_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5539(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5539_16; + operand.values[17] = tokenCoding5539_17; + operand.values[19] = tokenCoding5539_19; +} +x64Token x64Parser::tokenBranches5538[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5539, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5528_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5528_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5528_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5528(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5528_16; + operand.values[17] = tokenCoding5528_17; + operand.values[19] = tokenCoding5528_19; +} +Coding x64Parser::tokenCoding5529_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5529_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5529_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5529(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5529_16; + operand.values[17] = tokenCoding5529_17; + operand.values[19] = tokenCoding5529_19; +} +Coding x64Parser::tokenCoding5530_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5530_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5530_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5530(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5530_16; + operand.values[17] = tokenCoding5530_17; + operand.values[19] = tokenCoding5530_19; +} +Coding x64Parser::tokenCoding5531_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5531_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5531_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5531(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5531_16; + operand.values[17] = tokenCoding5531_17; + operand.values[19] = tokenCoding5531_19; +} +x64Token x64Parser::tokenBranches5527[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5528, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5529, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5530, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5531, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5532 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5534 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5536 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5538 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5543(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5542[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5543, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5541[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5542 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5546(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 463; +} +x64Token x64Parser::tokenBranches5545[] = { + {x64Token::REGISTER, 99, 1, 0, NULL,&x64Parser::TokenFunc5546, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5544[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5545 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5549_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5549_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5549_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5549(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5549_16; + operand.values[17] = tokenCoding5549_17; + operand.values[19] = tokenCoding5549_19; +} +x64Token x64Parser::tokenBranches5548[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc5549, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5551_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5551_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5551_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5551_16; + operand.values[17] = tokenCoding5551_17; + operand.values[19] = tokenCoding5551_19; +} +x64Token x64Parser::tokenBranches5550[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc5551, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5544(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5540[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches5541 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5544, x64Parser::tokenBranches5544 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5548 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5550 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5555(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 439; +} +x64Token x64Parser::tokenBranches5554[] = { + {x64Token::REGISTER, 99, 1, 0, NULL,&x64Parser::TokenFunc5555, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5553[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5554 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5553(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 439; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +void x64Parser::TokenFunc5557(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 464; +} +x64Token x64Parser::tokenBranches5552[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc5553, x64Parser::tokenBranches5553 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5557, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5560_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5560_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5560_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5560(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5560_16; + operand.values[17] = tokenCoding5560_17; + operand.values[19] = tokenCoding5560_19; +} +x64Token x64Parser::tokenBranches5559[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5560, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5562_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5562_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5562_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5562(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5562_16; + operand.values[17] = tokenCoding5562_17; + operand.values[19] = tokenCoding5562_19; +} +x64Token x64Parser::tokenBranches5561[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5562, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5558[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5559 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5561 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5565_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5565_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5565(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5565_16; + operand.values[17] = tokenCoding5565_17; +} +x64Token x64Parser::tokenBranches5564[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5565, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5563[] = { + {x64Token::TOKEN, 12, 0, 1, NULL, NULL, x64Parser::tokenBranches5564 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5568(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 465; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5567[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc5568, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5570(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 466; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5572(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 467; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5569[] = { + {x64Token::NUMBER, 12, 1, 0, NULL,&x64Parser::TokenFunc5570, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5572, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5573(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 466; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5574(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 467; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5566[] = { + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches5567 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5569 }, + {x64Token::NUMBER, 11, 1, 0, NULL,&x64Parser::TokenFunc5573, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5574, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5579_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5579_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5579(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5579_16; + operand.values[17] = tokenCoding5579_17; + operand.values[18] = tokenCoding5579_18; + operand.values[19] = tokenCoding5579_19; +} +x64Token x64Parser::tokenBranches5578[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5579, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5577[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5578 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5576[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5577 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5583_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5583_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5583(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5583_16; + operand.values[17] = tokenCoding5583_17; + operand.values[18] = tokenCoding5583_18; + operand.values[19] = tokenCoding5583_19; +} +x64Token x64Parser::tokenBranches5582[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5583, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5581[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5582 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5580[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5581 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5587_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5587_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5587(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5587_16; + operand.values[17] = tokenCoding5587_17; + operand.values[18] = tokenCoding5587_18; + operand.values[19] = tokenCoding5587_19; +} +x64Token x64Parser::tokenBranches5586[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5587, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5585[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5586 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5584[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5585 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5576(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5580(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5584(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5575[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5576, x64Parser::tokenBranches5576 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5580, x64Parser::tokenBranches5580 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5584, x64Parser::tokenBranches5584 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5590_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5590_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 4, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5590(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5590_16; + operand.values[17] = tokenCoding5590_17; + operand.values[18] = tokenCoding5590_18; + operand.values[19] = tokenCoding5590_19; +} +x64Token x64Parser::tokenBranches5589[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5590, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5588[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5589 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5604_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5604_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5604(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5604_16; + operand.values[17] = tokenCoding5604_17; + operand.values[18] = tokenCoding5604_18; + operand.values[19] = tokenCoding5604_19; +} +x64Token x64Parser::tokenBranches5603[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5604, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5594_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5594_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5594(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5594_16; + operand.values[17] = tokenCoding5594_17; + operand.values[18] = tokenCoding5594_18; + operand.values[19] = tokenCoding5594_19; +} +x64Token x64Parser::tokenBranches5593[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5594, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5603 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5592[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5593 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5608_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5608_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5608(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5608_16; + operand.values[17] = tokenCoding5608_17; + operand.values[18] = tokenCoding5608_18; + operand.values[19] = tokenCoding5608_19; +} +x64Token x64Parser::tokenBranches5607[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5608, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5612_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5612_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5612(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5612_16; + operand.values[17] = tokenCoding5612_17; + operand.values[18] = tokenCoding5612_18; + operand.values[19] = tokenCoding5612_19; +} +x64Token x64Parser::tokenBranches5611[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5612, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5597_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5597_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5597(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5597_16; + operand.values[17] = tokenCoding5597_17; + operand.values[18] = tokenCoding5597_18; + operand.values[19] = tokenCoding5597_19; +} +Coding x64Parser::tokenCoding5600_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5600_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5600(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5600_16; + operand.values[17] = tokenCoding5600_17; + operand.values[18] = tokenCoding5600_18; + operand.values[19] = tokenCoding5600_19; +} +x64Token x64Parser::tokenBranches5596[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5597, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5600, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5607 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5611 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5595[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5596 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5625_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5625_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5625(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5625_16; + operand.values[17] = tokenCoding5625_17; + operand.values[18] = tokenCoding5625_18; + operand.values[19] = tokenCoding5625_19; +} +x64Token x64Parser::tokenBranches5624[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc5625, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5629_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5629_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5629(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5629_16; + operand.values[17] = tokenCoding5629_17; + operand.values[18] = tokenCoding5629_18; + operand.values[19] = tokenCoding5629_19; +} +x64Token x64Parser::tokenBranches5628[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5629, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5633_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5633_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5633(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5633_16; + operand.values[17] = tokenCoding5633_17; + operand.values[18] = tokenCoding5633_18; + operand.values[19] = tokenCoding5633_19; +} +x64Token x64Parser::tokenBranches5632[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5633, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5615_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5615_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5615(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5615_16; + operand.values[17] = tokenCoding5615_17; + operand.values[18] = tokenCoding5615_18; + operand.values[19] = tokenCoding5615_19; +} +Coding x64Parser::tokenCoding5618_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5618_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5618(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5618_16; + operand.values[17] = tokenCoding5618_17; + operand.values[18] = tokenCoding5618_18; + operand.values[19] = tokenCoding5618_19; +} +Coding x64Parser::tokenCoding5621_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5621_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5621(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5621_16; + operand.values[17] = tokenCoding5621_17; + operand.values[18] = tokenCoding5621_18; + operand.values[19] = tokenCoding5621_19; +} +x64Token x64Parser::tokenBranches5614[] = { + {x64Token::ADDRESSCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc5615, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5618, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5621, }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5624 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5628 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5632 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5613[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5614 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5592(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5595(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5613(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5591[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5592, x64Parser::tokenBranches5592 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5595, x64Parser::tokenBranches5595 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5613, x64Parser::tokenBranches5613 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5637_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5637_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5637_19[] = { + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5637(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5637_16; + operand.values[17] = tokenCoding5637_17; + operand.values[19] = tokenCoding5637_19; +} +Coding x64Parser::tokenCoding5640_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5640_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5640_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5640(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5640_16; + operand.values[17] = tokenCoding5640_17; + operand.values[19] = tokenCoding5640_19; +} +Coding x64Parser::tokenCoding5643_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5643_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5643_19[] = { + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5643(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5643_16; + operand.values[17] = tokenCoding5643_17; + operand.values[19] = tokenCoding5643_19; +} +x64Token x64Parser::tokenBranches5636[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5637, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5640, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5643, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5636 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5648_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5648_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5648_19[] = { + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5648(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5648_16; + operand.values[17] = tokenCoding5648_17; + operand.values[19] = tokenCoding5648_19; +} +Coding x64Parser::tokenCoding5653_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5653_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5653_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5653(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5653_16; + operand.values[17] = tokenCoding5653_17; + operand.values[19] = tokenCoding5653_19; +} +x64Token x64Parser::tokenBranches5647[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5648, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5653, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5657_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5657_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5657_19[] = { + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5657(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5657_16; + operand.values[17] = tokenCoding5657_17; + operand.values[19] = tokenCoding5657_19; +} +x64Token x64Parser::tokenBranches5646[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5647 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5657, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5646 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5644[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5645 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5660_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5660_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5660_19[] = { + { CODING_NAME("one") Coding::stateFunc, 4 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5660(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5660_16; + operand.values[17] = tokenCoding5660_17; + operand.values[19] = tokenCoding5660_19; +} +Coding x64Parser::tokenCoding5663_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5663_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5663_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5663(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5663_16; + operand.values[17] = tokenCoding5663_17; + operand.values[19] = tokenCoding5663_19; +} +Coding x64Parser::tokenCoding5666_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5666_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5666_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5666(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5666_16; + operand.values[17] = tokenCoding5666_17; + operand.values[19] = tokenCoding5666_19; +} +x64Token x64Parser::tokenBranches5659[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5660, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5663, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5666, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5658[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5659 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5671_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5671_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5671_19[] = { + { CODING_NAME("one") Coding::stateFunc, 4 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5671(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5671_16; + operand.values[17] = tokenCoding5671_17; + operand.values[19] = tokenCoding5671_19; +} +Coding x64Parser::tokenCoding5676_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5676_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5676_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5676(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5676_16; + operand.values[17] = tokenCoding5676_17; + operand.values[19] = tokenCoding5676_19; +} +x64Token x64Parser::tokenBranches5670[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5671, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5676, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5680_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5680_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5680_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5680(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5680_16; + operand.values[17] = tokenCoding5680_17; + operand.values[19] = tokenCoding5680_19; +} +x64Token x64Parser::tokenBranches5669[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5670 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5680, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5668[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5669 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5667[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5668 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5687_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5687_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5687_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5687(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5687_16; + operand.values[17] = tokenCoding5687_17; + operand.values[19] = tokenCoding5687_19; +} +x64Token x64Parser::tokenBranches5686[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5687, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5683_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5683_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5683_19[] = { + { CODING_NAME("one") Coding::stateFunc, 5 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5683(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5683_16; + operand.values[17] = tokenCoding5683_17; + operand.values[19] = tokenCoding5683_19; +} +Coding x64Parser::tokenCoding5690_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5690_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5690_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5690(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5690_16; + operand.values[17] = tokenCoding5690_17; + operand.values[19] = tokenCoding5690_19; +} +x64Token x64Parser::tokenBranches5682[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5683, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5686 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5690, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5682 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5695_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5695_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5695_19[] = { + { CODING_NAME("one") Coding::stateFunc, 5 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5695(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5695_16; + operand.values[17] = tokenCoding5695_17; + operand.values[19] = tokenCoding5695_19; +} +Coding x64Parser::tokenCoding5700_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5700_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5700_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5700(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5700_16; + operand.values[17] = tokenCoding5700_17; + operand.values[19] = tokenCoding5700_19; +} +x64Token x64Parser::tokenBranches5694[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5695, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5700, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5704_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5704_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5704_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5704(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5704_16; + operand.values[17] = tokenCoding5704_17; + operand.values[19] = tokenCoding5704_19; +} +x64Token x64Parser::tokenBranches5693[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5694 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5704, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5692[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5693 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5691[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5692 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5711_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5711_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5711_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5711(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5711_16; + operand.values[17] = tokenCoding5711_17; + operand.values[19] = tokenCoding5711_19; +} +x64Token x64Parser::tokenBranches5710[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5711, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5707_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5707_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5707_19[] = { + { CODING_NAME("one") Coding::stateFunc, 6 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5707(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5707_16; + operand.values[17] = tokenCoding5707_17; + operand.values[19] = tokenCoding5707_19; +} +Coding x64Parser::tokenCoding5714_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5714_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5714_19[] = { + { CODING_NAME("") Coding::stateFunc, 6 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5714(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5714_16; + operand.values[17] = tokenCoding5714_17; + operand.values[19] = tokenCoding5714_19; +} +x64Token x64Parser::tokenBranches5706[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5707, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5710 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5714, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5705[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5706 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5719_16[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5719_17[] = { + { CODING_NAME("one") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5719_19[] = { + { CODING_NAME("one") Coding::stateFunc, 6 }, + { CODING_NAME("one") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5719(x64Operand &operand, int tokenPos) +{ + operand.values[25] = new Coding[2]; + CleanupValues.push_back(operand.values[25]); + operand.values[25]->type = Coding::number; + operand.values[25]->val = operands.size(); + operand.values[25]->bits = 0; + operand.values[25]->field = 0; + operand.values[25]->unary = 0; + operand.values[25]->binary = 0; + operand.values[25][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5719_16; + operand.values[17] = tokenCoding5719_17; + operand.values[19] = tokenCoding5719_19; +} +Coding x64Parser::tokenCoding5724_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5724_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5724_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5724(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5724_16; + operand.values[17] = tokenCoding5724_17; + operand.values[19] = tokenCoding5724_19; +} +x64Token x64Parser::tokenBranches5718[] = { + {x64Token::NUMBER, 18, 1, 0, NULL,&x64Parser::TokenFunc5719, }, + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5724, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5728_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5728_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5728_19[] = { + { CODING_NAME("") Coding::stateFunc, 6 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5728(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5728_16; + operand.values[17] = tokenCoding5728_17; + operand.values[19] = tokenCoding5728_19; +} +x64Token x64Parser::tokenBranches5717[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5718 }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5728, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5716[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5717 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5715[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5716 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5634[] = { + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5635 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5644 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5658 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5667 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5681 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5691 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5705 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5715 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5735_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5735_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5735(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5735_16; + operand.values[17] = tokenCoding5735_17; + operand.values[18] = tokenCoding5735_18; + operand.values[19] = tokenCoding5735_19; +} +Coding x64Parser::tokenCoding5741_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5741_19[] = { + { CODING_NAME("") Coding::stateFunc, 4 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5741(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5741_16; + operand.values[17] = tokenCoding5741_17; + operand.values[18] = tokenCoding5741_18; + operand.values[19] = tokenCoding5741_19; +} +x64Token x64Parser::tokenBranches5734[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5735, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5741, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5733[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5734 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5733(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5732[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc5733, x64Parser::tokenBranches5733 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5731[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5732 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5730[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5731 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5747_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5747_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5747(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5747_16; + operand.values[17] = tokenCoding5747_17; + operand.values[18] = tokenCoding5747_18; + operand.values[19] = tokenCoding5747_19; +} +Coding x64Parser::tokenCoding5753_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5753_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5753(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5753_16; + operand.values[17] = tokenCoding5753_17; + operand.values[18] = tokenCoding5753_18; + operand.values[19] = tokenCoding5753_19; +} +x64Token x64Parser::tokenBranches5746[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5747, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5753, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5745[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5746 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5745(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5744[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5745, x64Parser::tokenBranches5745 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5743[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5744 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5742[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5743 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5759_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5759_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5759(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5759_16; + operand.values[17] = tokenCoding5759_17; + operand.values[18] = tokenCoding5759_18; + operand.values[19] = tokenCoding5759_19; +} +Coding x64Parser::tokenCoding5765_16[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_17[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_18[] = { + { CODING_NAME("") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5765_19[] = { + { CODING_NAME("") Coding::stateFunc, 5 }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5765(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5765_16; + operand.values[17] = tokenCoding5765_17; + operand.values[18] = tokenCoding5765_18; + operand.values[19] = tokenCoding5765_19; +} +x64Token x64Parser::tokenBranches5758[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5759, }, + {x64Token::REGISTER, 9, 1, 0, NULL,&x64Parser::TokenFunc5765, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5757[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5758 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5757(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5756[] = { + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5757, x64Parser::tokenBranches5757 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5755[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5756 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5754[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5755 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5729[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5730 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5742 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5754 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5767_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5767_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5767(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5767_16; + operand.values[17] = tokenCoding5767_17; +} +x64Token x64Parser::tokenBranches5766[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5767, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5771_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5771_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5771_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5771(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5771_16; + operand.values[17] = tokenCoding5771_17; + operand.values[18] = tokenCoding5771_18; +} +x64Token x64Parser::tokenBranches5770[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5771, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5769[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5770 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5769(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5768[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5769, x64Parser::tokenBranches5769 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5775_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5775_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5775(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5775_16; + operand.values[17] = tokenCoding5775_17; + operand.values[18] = tokenCoding5775_18; + operand.values[19] = tokenCoding5775_19; +} +x64Token x64Parser::tokenBranches5774[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5775, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5773[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5774 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5778_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5778_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5778(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5778_16; + operand.values[17] = tokenCoding5778_17; + operand.values[18] = tokenCoding5778_18; + operand.values[19] = tokenCoding5778_19; +} +x64Token x64Parser::tokenBranches5777[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5778, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5776[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5777 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5773(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5772[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5773, x64Parser::tokenBranches5773 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5776 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5782_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5782_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5782(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5782_16; + operand.values[17] = tokenCoding5782_17; + operand.values[18] = tokenCoding5782_18; + operand.values[19] = tokenCoding5782_19; +} +x64Token x64Parser::tokenBranches5781[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5782, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5780[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5781 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5785_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5785_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5785(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5785_16; + operand.values[17] = tokenCoding5785_17; + operand.values[18] = tokenCoding5785_18; + operand.values[19] = tokenCoding5785_19; +} +x64Token x64Parser::tokenBranches5784[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5785, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5783[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5784 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5780(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5779[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5780, x64Parser::tokenBranches5780 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5783 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5789_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5789_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5789(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5789_16; + operand.values[17] = tokenCoding5789_17; + operand.values[18] = tokenCoding5789_18; + operand.values[19] = tokenCoding5789_19; +} +x64Token x64Parser::tokenBranches5788[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5789, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5787[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5788 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5792_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5792_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5792(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5792_16; + operand.values[17] = tokenCoding5792_17; + operand.values[18] = tokenCoding5792_18; + operand.values[19] = tokenCoding5792_19; +} +x64Token x64Parser::tokenBranches5791[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5792, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5790[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5791 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5787(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5786[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5787, x64Parser::tokenBranches5787 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5790 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5796_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5796_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5796_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5796(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5796_16; + operand.values[17] = tokenCoding5796_17; + operand.values[18] = tokenCoding5796_18; +} +x64Token x64Parser::tokenBranches5795[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5796, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5794[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5795 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5794(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5793[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5794, x64Parser::tokenBranches5794 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5800_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5800_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5800_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5800(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5800_16; + operand.values[17] = tokenCoding5800_17; + operand.values[18] = tokenCoding5800_18; +} +x64Token x64Parser::tokenBranches5799[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5800, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5798[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5799 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5798(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5797[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5798, x64Parser::tokenBranches5798 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5804_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5804_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5804_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5804(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5804_16; + operand.values[17] = tokenCoding5804_17; + operand.values[18] = tokenCoding5804_18; +} +x64Token x64Parser::tokenBranches5803[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc5804, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5802[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5803 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5807_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5807_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5807_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5807(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5807_16; + operand.values[17] = tokenCoding5807_17; + operand.values[18] = tokenCoding5807_18; +} +x64Token x64Parser::tokenBranches5806[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc5807, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5805[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5806 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5802(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5805(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5801[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc5802, x64Parser::tokenBranches5802 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc5805, x64Parser::tokenBranches5805 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5812_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5812_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5812_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5812(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5812_16; + operand.values[17] = tokenCoding5812_17; + operand.values[18] = tokenCoding5812_18; +} +x64Token x64Parser::tokenBranches5811[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc5812, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5816_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5816_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5816_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5816(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5816_16; + operand.values[17] = tokenCoding5816_17; + operand.values[18] = tokenCoding5816_18; +} +x64Token x64Parser::tokenBranches5815[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5816, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5810[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5811 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5815 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5809[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5810 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5809(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5808[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5809, x64Parser::tokenBranches5809 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5820_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5820_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5820(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5820_16; + operand.values[17] = tokenCoding5820_17; + operand.values[23] = tokenCoding5820_23; + operand.values[18] = tokenCoding5820_18; +} +x64Token x64Parser::tokenBranches5819[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5820, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5818[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5819 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5823_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5823_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5823(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5823_16; + operand.values[17] = tokenCoding5823_17; + operand.values[23] = tokenCoding5823_23; + operand.values[18] = tokenCoding5823_18; +} +x64Token x64Parser::tokenBranches5822[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5823, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5821[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5822 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5818(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5821(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5817[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5818, x64Parser::tokenBranches5818 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5821, x64Parser::tokenBranches5821 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5829_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5829_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5829_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5829(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5829_16; + operand.values[17] = tokenCoding5829_17; + operand.values[18] = tokenCoding5829_18; +} +x64Token x64Parser::tokenBranches5828[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5829, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5827[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5828 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5826[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5827 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5825[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5826 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5825(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5824[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5825, x64Parser::tokenBranches5825 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5833_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5833_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5833(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5833_16; + operand.values[17] = tokenCoding5833_17; + operand.values[23] = tokenCoding5833_23; + operand.values[18] = tokenCoding5833_18; + operand.values[19] = tokenCoding5833_19; +} +x64Token x64Parser::tokenBranches5832[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5833, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5831[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5832 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5836_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5836_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5836(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5836_16; + operand.values[17] = tokenCoding5836_17; + operand.values[23] = tokenCoding5836_23; + operand.values[18] = tokenCoding5836_18; + operand.values[19] = tokenCoding5836_19; +} +x64Token x64Parser::tokenBranches5835[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5836, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5834[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5835 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5839_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5839_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5839(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5839_16; + operand.values[17] = tokenCoding5839_17; + operand.values[23] = tokenCoding5839_23; + operand.values[18] = tokenCoding5839_18; + operand.values[19] = tokenCoding5839_19; +} +x64Token x64Parser::tokenBranches5838[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc5839, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5837[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5838 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5842_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5842_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5842(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5842_16; + operand.values[17] = tokenCoding5842_17; + operand.values[23] = tokenCoding5842_23; + operand.values[18] = tokenCoding5842_18; + operand.values[19] = tokenCoding5842_19; +} +x64Token x64Parser::tokenBranches5841[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc5842, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5840[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5841 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5837(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc5840(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5830[] = { + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches5831 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches5834 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5837, x64Parser::tokenBranches5837 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5840, x64Parser::tokenBranches5840 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5848_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5848_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5848_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5848(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5848_16; + operand.values[17] = tokenCoding5848_17; + operand.values[18] = tokenCoding5848_18; +} +x64Token x64Parser::tokenBranches5847[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5848, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5846[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5847 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5845[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5846 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5844[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5845 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5844(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5843[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc5844, x64Parser::tokenBranches5844 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5854_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5854_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5854_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5854(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding5854_16; + operand.values[17] = tokenCoding5854_17; + operand.values[18] = tokenCoding5854_18; +} +x64Token x64Parser::tokenBranches5853[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc5854, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5852[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5853 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5851[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5852 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5850[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5851 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5850(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5849[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc5850, x64Parser::tokenBranches5850 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5865_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5865_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5865(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5865_16; + operand.values[17] = tokenCoding5865_17; + operand.values[18] = tokenCoding5865_18; + operand.values[19] = tokenCoding5865_19; +} +x64Token x64Parser::tokenBranches5864[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc5865, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5863[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5864 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5862[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5863 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5870_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5870_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5870_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5870(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 469; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5870_16; + operand.values[17] = tokenCoding5870_17; + operand.values[18] = tokenCoding5870_18; +} +Coding x64Parser::tokenCoding5871_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5871_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5871_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5871(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 470; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding5871_16; + operand.values[17] = tokenCoding5871_17; + operand.values[18] = tokenCoding5871_18; +} +x64Token x64Parser::tokenBranches5869[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc5870, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc5871, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5880(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 471; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5879[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc5880, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5884(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 472; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches5883[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc5884, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5878[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5879 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5883 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5877[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5878 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5892_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5892_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5892(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5892_16; + operand.values[17] = tokenCoding5892_17; + operand.values[18] = tokenCoding5892_18; + operand.values[19] = tokenCoding5892_19; +} +x64Token x64Parser::tokenBranches5891[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5892, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5894_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5894_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5894(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5894_16; + operand.values[17] = tokenCoding5894_17; + operand.values[18] = tokenCoding5894_18; + operand.values[19] = tokenCoding5894_19; +} +x64Token x64Parser::tokenBranches5893[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5894, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5896_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5896_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5896(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5896_16; + operand.values[17] = tokenCoding5896_17; + operand.values[18] = tokenCoding5896_18; + operand.values[19] = tokenCoding5896_19; +} +x64Token x64Parser::tokenBranches5895[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5896, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5905_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5905_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5905(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5905_16; + operand.values[17] = tokenCoding5905_17; + operand.values[18] = tokenCoding5905_18; + operand.values[19] = tokenCoding5905_19; +} +x64Token x64Parser::tokenBranches5904[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5905, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding5908_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5908_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5908(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5908_16; + operand.values[17] = tokenCoding5908_17; + operand.values[18] = tokenCoding5908_18; + operand.values[19] = tokenCoding5908_19; +} +x64Token x64Parser::tokenBranches5907[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5908, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5898(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 475; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5900(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 476; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding5902_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5902_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5902(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5902_16; + operand.values[17] = tokenCoding5902_17; + operand.values[18] = tokenCoding5902_18; + operand.values[19] = tokenCoding5902_19; +} +x64Token x64Parser::tokenBranches5897[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc5898, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc5900, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5902, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5904 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5907 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5877(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::number; + operand.values[2]->val = operands.size(); + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5885(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 473; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc5886(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 474; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding5887_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5887_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5887(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5887_16; + operand.values[17] = tokenCoding5887_17; + operand.values[18] = tokenCoding5887_18; + operand.values[19] = tokenCoding5887_19; +} +Coding x64Parser::tokenCoding5888_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5888_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5888(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5888_16; + operand.values[17] = tokenCoding5888_17; + operand.values[18] = tokenCoding5888_18; + operand.values[19] = tokenCoding5888_19; +} +Coding x64Parser::tokenCoding5889_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5889_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5889(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5889_16; + operand.values[17] = tokenCoding5889_17; + operand.values[18] = tokenCoding5889_18; + operand.values[19] = tokenCoding5889_19; +} +Coding x64Parser::tokenCoding5890_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding5890_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc5890(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding5890_16; + operand.values[17] = tokenCoding5890_17; + operand.values[18] = tokenCoding5890_18; + operand.values[19] = tokenCoding5890_19; +} +x64Token x64Parser::tokenBranches5876[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc5877, x64Parser::tokenBranches5877 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc5885, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc5886, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc5887, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc5888, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc5889, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc5890, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5891 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5893 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5895 }, + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches5897 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5912(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 477; +} +x64Token x64Parser::tokenBranches5911[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc5912, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5962(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 478; +} +x64Token x64Parser::tokenBranches5961[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5962, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5960[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5961 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5959[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5960 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5958[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5959 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5957[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5958 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5956[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5957 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5955[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5956 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5954[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5955 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5988(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 480; +} +x64Token x64Parser::tokenBranches5987[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5988, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5986[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches5987 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5985[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5986 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5984[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5985 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5983[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5984 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5982[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5983 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5981[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5982 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5980[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5981 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5953[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5954 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5980 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5952[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5953 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5975(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 479; +} +x64Token x64Parser::tokenBranches5974[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc5975, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5973[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5974 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5972[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5973 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5971[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5972 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5970[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5971 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5969[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5970 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5968[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5969 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5967[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5968 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6001(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 481; +} +x64Token x64Parser::tokenBranches6000[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6001, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5999[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6000 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5998[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5999 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5997[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5998 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5996[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5997 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5995[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5996 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5994[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5995 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5993[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5994 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6023(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 483; +} +x64Token x64Parser::tokenBranches6022[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6023, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6021[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6022 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6020[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6021 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6019[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6020 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6018[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6019 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6017[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6018 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6016[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6017 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6015[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6016 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5966[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5967 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5993 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6015 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5965[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5966 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6010(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 482; +} +x64Token x64Parser::tokenBranches6009[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6010, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6008[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6009 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6007[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6008 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6006[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6007 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6005[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6006 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6004[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6005 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc5965(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches5951[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches5952 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc5965, x64Parser::tokenBranches5965 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6004 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5950[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5951 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6036(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 484; +} +x64Token x64Parser::tokenBranches6035[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6036, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6034[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6035 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6033[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6034 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6032[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6033 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6031[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6032 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6030[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6031 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6029[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6030 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6028[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6029 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6062(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 486; +} +x64Token x64Parser::tokenBranches6061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6062, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6060[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6061 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6059[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6060 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6058[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6059 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6057[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6058 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6056[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6057 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6055[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6056 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6054[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6055 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6027[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6028 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6054 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6026[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6027 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6049(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 485; +} +x64Token x64Parser::tokenBranches6048[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6049, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6047[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6048 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6046[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6047 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6045[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6046 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6044[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6045 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6043[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6044 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6042[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6043 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6041[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6042 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6075(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 487; +} +x64Token x64Parser::tokenBranches6074[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6075, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6073[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6074 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6072[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6073 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6071[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6072 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6070[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6071 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6069[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6070 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6068[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6069 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6067[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6068 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6095(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 489; +} +x64Token x64Parser::tokenBranches6094[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6095, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6093[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6094 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6092[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6093 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6091[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6092 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6090[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6091 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6089[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6090 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6040[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6041 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6067 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6089 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6039[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6040 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6084(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 488; +} +x64Token x64Parser::tokenBranches6083[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6084, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6082[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6083 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6081[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6082 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6080[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6081 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6079[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6080 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6078[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6079 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6039(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6025[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6026 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6039, x64Parser::tokenBranches6039 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6078 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6024[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6025 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6108(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 490; +} +x64Token x64Parser::tokenBranches6107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6108, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6107 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6105[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6106 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6104[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6105 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6103[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6104 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6102[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6103 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6101[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6102 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6100[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6101 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6134(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 492; +} +x64Token x64Parser::tokenBranches6133[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6134, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6132[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6133 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6131[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6132 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6130[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6131 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6129[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6130 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6128[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6129 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6127[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6128 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6126[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6127 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6099[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6100 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6126 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6098[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6099 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6121(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 491; +} +x64Token x64Parser::tokenBranches6120[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6121, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6119[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6120 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6118[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6119 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6117[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6118 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6116[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6117 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6115[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6116 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6114[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6115 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6113[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6114 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6147(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 493; +} +x64Token x64Parser::tokenBranches6146[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6147, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6145[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6146 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6144[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6145 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6143[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6144 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6142[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6143 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6141[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6142 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6140[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6141 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6139[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6140 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6167(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 495; +} +x64Token x64Parser::tokenBranches6166[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6167, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6165[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6166 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6164[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6165 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6163[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6164 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6162[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6163 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6161[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6162 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6112[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6113 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6139 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6161 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6111[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6112 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6156(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 494; +} +x64Token x64Parser::tokenBranches6155[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6156, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6154[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6155 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6153[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6154 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6152[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6153 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6151[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6152 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6150[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6151 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6111(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6097[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6098 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6111, x64Parser::tokenBranches6111 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6150 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6096[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6097 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6180(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 496; +} +x64Token x64Parser::tokenBranches6179[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6180, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6178[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6179 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6177[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6176[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6177 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6175[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6176 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6174[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6175 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6173[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6174 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6172[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6173 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6171[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6172 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6170[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6171 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6193(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 497; +} +x64Token x64Parser::tokenBranches6192[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6193, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6191[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6192 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6190[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6191 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6189[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6190 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6188[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6189 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6187[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6188 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6186[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6187 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6185[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6186 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6213(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 499; +} +x64Token x64Parser::tokenBranches6212[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6213, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6211[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6212 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6210[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6211 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6209[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6210 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6208[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6209 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6207[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6208 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6184[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6185 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6207 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6183[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6184 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6202(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 498; +} +x64Token x64Parser::tokenBranches6201[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6202, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6200[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6201 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6199[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6200 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6198[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6199 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6197 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6183(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6169[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6170 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6183, x64Parser::tokenBranches6183 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6196 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6168[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6169 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches5949[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5950 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6024 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6096 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6168 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6218(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 500; +} +x64Token x64Parser::tokenBranches6217[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6218, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6223_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6223_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6223(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6223_16; + operand.values[17] = tokenCoding6223_17; + operand.values[18] = tokenCoding6223_18; + operand.values[19] = tokenCoding6223_19; +} +Coding x64Parser::tokenCoding6227_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6227_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6227(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6227_16; + operand.values[17] = tokenCoding6227_17; + operand.values[23] = tokenCoding6227_23; + operand.values[18] = tokenCoding6227_18; + operand.values[19] = tokenCoding6227_19; +} +x64Token x64Parser::tokenBranches6222[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6223, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc6227, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6221[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6222 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6220[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6221 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6231_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6231_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6231(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6231_16; + operand.values[17] = tokenCoding6231_17; + operand.values[18] = tokenCoding6231_18; + operand.values[19] = tokenCoding6231_19; +} +x64Token x64Parser::tokenBranches6230[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6231, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6230 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6228[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6229 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6235_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6235_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6235(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6235_16; + operand.values[17] = tokenCoding6235_17; + operand.values[18] = tokenCoding6235_18; + operand.values[19] = tokenCoding6235_19; +} +x64Token x64Parser::tokenBranches6234[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6235, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6233[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6234 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6232[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches6233 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6239_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6239_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6239(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding6239_16; + operand.values[17] = tokenCoding6239_17; + operand.values[18] = tokenCoding6239_18; + operand.values[19] = tokenCoding6239_19; +} +x64Token x64Parser::tokenBranches6238[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc6239, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6238 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6236[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6237 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6219[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6220 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6228 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6232 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6236 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6241_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6241_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6241(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6241_16; + operand.values[17] = tokenCoding6241_17; + operand.values[18] = tokenCoding6241_18; + operand.values[19] = tokenCoding6241_19; +} +x64Token x64Parser::tokenBranches6240[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6241, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6243_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6243_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6243(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6243_16; + operand.values[17] = tokenCoding6243_17; + operand.values[18] = tokenCoding6243_18; + operand.values[19] = tokenCoding6243_19; +} +x64Token x64Parser::tokenBranches6242[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6243, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6246(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 501; +} +x64Token x64Parser::tokenBranches6245[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6246, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 502; + operand.values[27] = new Coding[2]; + CleanupValues.push_back(operand.values[27]); + operand.values[27]->type = Coding::number; + operand.values[27]->val = operands.size(); + operand.values[27]->bits = 0; + operand.values[27]->field = 0; + operand.values[27]->unary = 0; + operand.values[27]->binary = 0; + operand.values[27][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6257[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6258, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6256[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6255[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6254[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6255, x64Parser::tokenBranches6255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6253[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6262_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&' }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6262_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>' }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6262(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6262_16; + operand.values[17] = tokenCoding6262_17; + operand.values[18] = tokenCoding6262_18; + operand.values[19] = tokenCoding6262_19; +} +x64Token x64Parser::tokenBranches6261[] = { + {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6262, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6260[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6259[] = { + {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6260, x64Parser::tokenBranches6260 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6274[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6275, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6273[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6272[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6278[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6279, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6277[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6276[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6282[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6283, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6281[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6280[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6286[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6287, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6285[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6284[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6290[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6291, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6289[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6288[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6294[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6295, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6293[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6292[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6298[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6299, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6296[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6302[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6303, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6301[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6300[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6306[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6307, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6310_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6310_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6310_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6310(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6310_16; + operand.values[17] = tokenCoding6310_17; + operand.values[19] = tokenCoding6310_19; +} +x64Token x64Parser::tokenBranches6309[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6310, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6312_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6312_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6312_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6312(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6312_16; + operand.values[17] = tokenCoding6312_17; + operand.values[19] = tokenCoding6312_19; +} +x64Token x64Parser::tokenBranches6311[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6312, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6304[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6308, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6315[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6316, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6313[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6319[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6320, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6318[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6317[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6324_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6324_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6324_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6324(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6324_16; + operand.values[17] = tokenCoding6324_17; + operand.values[19] = tokenCoding6324_19; +} +x64Token x64Parser::tokenBranches6323[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6324, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6326_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6326_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6326_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6326_16; + operand.values[17] = tokenCoding6326_17; + operand.values[19] = tokenCoding6326_19; +} +x64Token x64Parser::tokenBranches6325[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6326, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6321[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6337_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6337_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6337(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6337_18; + operand.values[19] = tokenCoding6337_19; +} +x64Token x64Parser::tokenBranches6336[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6337, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6339_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6339_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6339(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6339_18; + operand.values[19] = tokenCoding6339_19; +} +x64Token x64Parser::tokenBranches6338[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6339, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6347_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6347_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6347(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6347_16; + operand.values[17] = tokenCoding6347_17; + operand.values[18] = tokenCoding6347_18; + operand.values[19] = tokenCoding6347_19; +} +x64Token x64Parser::tokenBranches6346[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6347, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6349_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6349_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6349(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6349_16; + operand.values[17] = tokenCoding6349_17; + operand.values[18] = tokenCoding6349_18; + operand.values[19] = tokenCoding6349_19; +} +x64Token x64Parser::tokenBranches6348[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6349, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6351_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6351_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6351(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6351_16; + operand.values[17] = tokenCoding6351_17; + operand.values[18] = tokenCoding6351_18; + operand.values[19] = tokenCoding6351_19; +} +x64Token x64Parser::tokenBranches6350[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6351, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6345[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6359_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6359_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6359(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6359_16; + operand.values[17] = tokenCoding6359_17; + operand.values[18] = tokenCoding6359_18; + operand.values[19] = tokenCoding6359_19; +} +x64Token x64Parser::tokenBranches6358[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6359, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6361_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6361_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6361(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6361_16; + operand.values[17] = tokenCoding6361_17; + operand.values[18] = tokenCoding6361_18; + operand.values[19] = tokenCoding6361_19; +} +x64Token x64Parser::tokenBranches6360[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6361, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6357[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6367_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6367_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6367_16; + operand.values[17] = tokenCoding6367_17; + operand.values[18] = tokenCoding6367_18; + operand.values[19] = tokenCoding6367_19; +} +x64Token x64Parser::tokenBranches6366[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6369_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6369_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6369(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6369_16; + operand.values[17] = tokenCoding6369_17; + operand.values[18] = tokenCoding6369_18; + operand.values[19] = tokenCoding6369_19; +} +x64Token x64Parser::tokenBranches6368[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6369, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6371_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6371_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6371_16; + operand.values[17] = tokenCoding6371_17; + operand.values[18] = tokenCoding6371_18; + operand.values[19] = tokenCoding6371_19; +} +x64Token x64Parser::tokenBranches6370[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6371, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6365_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6365_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6365_18; + operand.values[19] = tokenCoding6365_19; +} +x64Token x64Parser::tokenBranches6364[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6365, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6375_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6375_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6375_16; + operand.values[17] = tokenCoding6375_17; + operand.values[18] = tokenCoding6375_18; + operand.values[19] = tokenCoding6375_19; +} +x64Token x64Parser::tokenBranches6374[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6373[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6377_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6377_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6377_16; + operand.values[17] = tokenCoding6377_17; + operand.values[18] = tokenCoding6377_18; + operand.values[19] = tokenCoding6377_19; +} +x64Token x64Parser::tokenBranches6376[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6388_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6388_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6388(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6388_16; + operand.values[17] = tokenCoding6388_17; + operand.values[18] = tokenCoding6388_18; + operand.values[19] = tokenCoding6388_19; +} +x64Token x64Parser::tokenBranches6387[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6388, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6395_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6395_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5300_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6395(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6395_16; + operand.values[17] = tokenCoding6395_17; + operand.values[18] = tokenCoding6395_18; + operand.values[19] = tokenCoding6395_19; +} +x64Token x64Parser::tokenBranches6394[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6395, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5300_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5300(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5300_16; - operand.values[17] = tokenCoding5300_17; - operand.values[18] = tokenCoding5300_18; - operand.values[19] = tokenCoding5300_19; -} -x64Token x64Parser::tokenBranches5299[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5300, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5298[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5299}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5297[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5298}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5304_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5304_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5304(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5304_16; - operand.values[17] = tokenCoding5304_17; - operand.values[18] = tokenCoding5304_18; - operand.values[19] = tokenCoding5304_19; -} -x64Token x64Parser::tokenBranches5303[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5304, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5302[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5303}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5301[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5302}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5308_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6397_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5308_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6397(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6397_16; + operand.values[17] = tokenCoding6397_17; + operand.values[18] = tokenCoding6397_18; + operand.values[19] = tokenCoding6397_19; +} +x64Token x64Parser::tokenBranches6396[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6397, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5308_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6406_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5308_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5308(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5308_16; - operand.values[17] = tokenCoding5308_17; - operand.values[18] = tokenCoding5308_18; - operand.values[19] = tokenCoding5308_19; -} -x64Token x64Parser::tokenBranches5307[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5308, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5306[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5307}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5305[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5306}, {x64Token::EOT}}; -void x64Parser::TokenFunc5297(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5301(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5305(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding6406_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6406_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6406_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6406(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6406_16; + operand.values[17] = tokenCoding6406_17; + operand.values[18] = tokenCoding6406_18; + operand.values[19] = tokenCoding6406_19; } -x64Token x64Parser::tokenBranches5296[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5297, x64Parser::tokenBranches5297}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5301, x64Parser::tokenBranches5301}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5305, x64Parser::tokenBranches5305}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5313(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 445; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5312[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5313, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5311[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5312}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5310[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5311}, {x64Token::EOT}}; -void x64Parser::TokenFunc5317(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 446; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5316[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5317, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5315[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5316}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5315}, {x64Token::EOT}}; -void x64Parser::TokenFunc5321(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 447; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5320[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5321, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5319[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5320}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5318[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5319}, {x64Token::EOT}}; -void x64Parser::TokenFunc5325(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 448; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5324[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5325, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5323[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5324}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5322[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5323}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5329_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6405[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6406, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5329_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5329_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5329_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5329(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5329_16; - operand.values[17] = tokenCoding5329_17; - operand.values[18] = tokenCoding5329_18; - operand.values[19] = tokenCoding5329_19; -} -x64Token x64Parser::tokenBranches5328[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5329, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5327[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5328}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5326[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5327}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5333_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6408_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6408(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6408_16; + operand.values[17] = tokenCoding6408_17; + operand.values[18] = tokenCoding6408_18; + operand.values[19] = tokenCoding6408_19; +} +x64Token x64Parser::tokenBranches6407[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6408, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5333_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6404_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5333_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5333(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5333_16; - operand.values[17] = tokenCoding5333_17; - operand.values[23] = tokenCoding5333_23; - operand.values[18] = tokenCoding5333_18; - operand.values[19] = tokenCoding5333_19; -} -x64Token x64Parser::tokenBranches5332[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5333, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5331[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5332}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5330[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5331}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5337_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6404_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5337_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6404(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6404_18; + operand.values[19] = tokenCoding6404_19; +} +x64Token x64Parser::tokenBranches6403[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6404, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5337_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5337_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5337(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5337_16; - operand.values[17] = tokenCoding5337_17; - operand.values[18] = tokenCoding5337_18; - operand.values[19] = tokenCoding5337_19; -} -x64Token x64Parser::tokenBranches5336[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5337, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5335[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5336}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5334[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5335}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5341_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6411_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5341_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5341(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5341_16; - operand.values[17] = tokenCoding5341_17; - operand.values[18] = tokenCoding5341_18; - operand.values[19] = tokenCoding5341_19; -} -x64Token x64Parser::tokenBranches5340[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5341, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5339[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5340}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5338[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5339}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5345_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6411(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6411_16; + operand.values[17] = tokenCoding6411_17; + operand.values[18] = tokenCoding6411_18; + operand.values[19] = tokenCoding6411_19; +} +x64Token x64Parser::tokenBranches6410[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6411, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5345_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6409[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5345_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5345_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5345(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5345_16; - operand.values[17] = tokenCoding5345_17; - operand.values[18] = tokenCoding5345_18; - operand.values[19] = tokenCoding5345_19; -} -x64Token x64Parser::tokenBranches5344[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5345, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5343[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5344}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5342[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5343}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5349_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6414_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5349_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5349(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5349_16; - operand.values[17] = tokenCoding5349_17; - operand.values[18] = tokenCoding5349_18; - operand.values[19] = tokenCoding5349_19; +void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6414_16; + operand.values[17] = tokenCoding6414_17; + operand.values[18] = tokenCoding6414_18; + operand.values[19] = tokenCoding6414_19; } -Coding x64Parser::tokenCoding5353_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6413[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6414, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5353_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6412[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5353_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5353_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5353_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 37, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5353(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5353_16; - operand.values[17] = tokenCoding5353_17; - operand.values[23] = tokenCoding5353_23; - operand.values[18] = tokenCoding5353_18; - operand.values[19] = tokenCoding5353_19; -} -x64Token x64Parser::tokenBranches5348[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5349, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5353, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5347[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5348}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5346[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5347}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5357_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5357_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6416_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5357_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6416(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6416_16; + operand.values[17] = tokenCoding6416_17; + operand.values[18] = tokenCoding6416_18; + operand.values[19] = tokenCoding6416_19; +} +x64Token x64Parser::tokenBranches6415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6416, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5357_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5357(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5357_16; - operand.values[17] = tokenCoding5357_17; - operand.values[18] = tokenCoding5357_18; - operand.values[19] = tokenCoding5357_19; -} -x64Token x64Parser::tokenBranches5356[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5357, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5355[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5356}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5354[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5355}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5361_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5361_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5361(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5361_16; - operand.values[17] = tokenCoding5361_17; - operand.values[18] = tokenCoding5361_18; - operand.values[19] = tokenCoding5361_19; -} -x64Token x64Parser::tokenBranches5360[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5361, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5359[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5360}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5358[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5359}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5365_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6418_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5365_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6418(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6418_16; + operand.values[17] = tokenCoding6418_17; + operand.values[18] = tokenCoding6418_18; + operand.values[19] = tokenCoding6418_19; +} +x64Token x64Parser::tokenBranches6417[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6418, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5365_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5365_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5365(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5365_16; - operand.values[17] = tokenCoding5365_17; - operand.values[18] = tokenCoding5365_18; - operand.values[19] = tokenCoding5365_19; -} -x64Token x64Parser::tokenBranches5364[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5365, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5363[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5364}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5362[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5363}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5370_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5370_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5370_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5370(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5370_16; - operand.values[17] = tokenCoding5370_17; - operand.values[19] = tokenCoding5370_19; -} -x64Token x64Parser::tokenBranches5369[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5370, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5368[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5369}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5367[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5368}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5366[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5367}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5375_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6422_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6422_16; + operand.values[17] = tokenCoding6422_17; + operand.values[18] = tokenCoding6422_18; + operand.values[19] = tokenCoding6422_19; +} +x64Token x64Parser::tokenBranches6421[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6422, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6424_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6424_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6424_16; + operand.values[17] = tokenCoding6424_17; + operand.values[18] = tokenCoding6424_18; + operand.values[19] = tokenCoding6424_19; +} +x64Token x64Parser::tokenBranches6423[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6424, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6426_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6426_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6426_16; + operand.values[17] = tokenCoding6426_17; + operand.values[18] = tokenCoding6426_18; + operand.values[19] = tokenCoding6426_19; +} +x64Token x64Parser::tokenBranches6425[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6426, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6420_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6420_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) +{ + operand.values[18] = tokenCoding6420_18; + operand.values[19] = tokenCoding6420_19; +} +x64Token x64Parser::tokenBranches6419[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6420, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6429_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6429_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6429(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6429_16; + operand.values[17] = tokenCoding6429_17; + operand.values[18] = tokenCoding6429_18; + operand.values[19] = tokenCoding6429_19; +} +x64Token x64Parser::tokenBranches6428[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6429, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 503; +} +x64Token x64Parser::tokenBranches6427[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6433_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6433_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6433(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6433_16; + operand.values[17] = tokenCoding6433_17; + operand.values[18] = tokenCoding6433_18; + operand.values[19] = tokenCoding6433_19; +} +x64Token x64Parser::tokenBranches6432[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6433, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6434(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 504; +} +x64Token x64Parser::tokenBranches6431[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6434, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6443[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6444, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6442[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6441[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6447[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6448, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6446[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6445[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6456[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6457, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6455[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6454[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 462; + operand.values[15] = new Coding[2]; + CleanupValues.push_back(operand.values[15]); + operand.values[15]->type = Coding::reg; + operand.values[15]->val = inputTokens[tokenPos]->val->ival; + operand.values[15]->bits = 0; + operand.values[15]->field = 0; + operand.values[15]->unary = 0; + operand.values[15]->binary = 0; + operand.values[15][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6460[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6461, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6459[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6458[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6463_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6463_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6463_16; + operand.values[17] = tokenCoding6463_17; + operand.values[18] = tokenCoding6463_18; + operand.values[19] = tokenCoding6463_19; +} +x64Token x64Parser::tokenBranches6462[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6463, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6465_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6465_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6465(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6465_16; + operand.values[17] = tokenCoding6465_17; + operand.values[18] = tokenCoding6465_18; + operand.values[19] = tokenCoding6465_19; +} +x64Token x64Parser::tokenBranches6464[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6465, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 505; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6475[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6476, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6503_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6503_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 4 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6503_16; + operand.values[17] = tokenCoding6503_17; + operand.values[18] = tokenCoding6503_18; + operand.values[19] = tokenCoding6503_19; +} +x64Token x64Parser::tokenBranches6502[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6503, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6509_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6509_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6509_16; + operand.values[17] = tokenCoding6509_17; + operand.values[18] = tokenCoding6509_18; + operand.values[19] = tokenCoding6509_19; +} +x64Token x64Parser::tokenBranches6501[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502 }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6509, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6500[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 506; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6500_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6500_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6500(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6500_16; + operand.values[17] = tokenCoding6500_17; + operand.values[18] = tokenCoding6500_18; + operand.values[19] = tokenCoding6500_19; +} +x64Token x64Parser::tokenBranches6479[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6480, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6500, x64Parser::tokenBranches6500 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6474[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6473[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 507; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6483[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6484, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6520_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6520_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 5 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6520_16; + operand.values[17] = tokenCoding6520_17; + operand.values[18] = tokenCoding6520_18; + operand.values[19] = tokenCoding6520_19; +} +x64Token x64Parser::tokenBranches6519[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6520, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6526_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6526_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6526_16; + operand.values[17] = tokenCoding6526_17; + operand.values[18] = tokenCoding6526_18; + operand.values[19] = tokenCoding6526_19; +} +x64Token x64Parser::tokenBranches6518[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6526, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6517[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 508; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6517_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6517_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6517(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6517_16; + operand.values[17] = tokenCoding6517_17; + operand.values[18] = tokenCoding6517_18; + operand.values[19] = tokenCoding6517_19; +} +x64Token x64Parser::tokenBranches6487[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6488, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6517, x64Parser::tokenBranches6517 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6482[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6481[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 509; + operand.values[24] = new Coding[2]; + CleanupValues.push_back(operand.values[24]); + operand.values[24]->type = Coding::number; + operand.values[24]->val = operands.size(); + operand.values[24]->bits = 0; + operand.values[24]->field = 0; + operand.values[24]->unary = 0; + operand.values[24]->binary = 0; + operand.values[24][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6491[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6492, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6537_16[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_17[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_18[] = { + { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6537_19[] = { + { CODING_NAME("isigned") Coding::stateFunc, 6 }, + { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 511; + operand.values[28] = new Coding[2]; + CleanupValues.push_back(operand.values[28]); + operand.values[28]->type = Coding::number; + operand.values[28]->val = operands.size(); + operand.values[28]->bits = 0; + operand.values[28]->field = 0; + operand.values[28]->unary = 0; + operand.values[28]->binary = 0; + operand.values[28][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6537_16; + operand.values[17] = tokenCoding6537_17; + operand.values[18] = tokenCoding6537_18; + operand.values[19] = tokenCoding6537_19; +} +x64Token x64Parser::tokenBranches6536[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6537, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6543_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6543_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding6543_16; + operand.values[17] = tokenCoding6543_17; + operand.values[18] = tokenCoding6543_18; + operand.values[19] = tokenCoding6543_19; +} +x64Token x64Parser::tokenBranches6535[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6543, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6534[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 510; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6534_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5375_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5375_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5375(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5375_16; - operand.values[17] = tokenCoding5375_17; - operand.values[19] = tokenCoding5375_19; -} -x64Token x64Parser::tokenBranches5374[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5375, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5380_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5380_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6534_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5380_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5380(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5380_16; - operand.values[17] = tokenCoding5380_17; - operand.values[19] = tokenCoding5380_19; +void x64Parser::TokenFunc6534(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6534_16; + operand.values[17] = tokenCoding6534_17; + operand.values[18] = tokenCoding6534_18; + operand.values[19] = tokenCoding6534_19; } -Coding x64Parser::tokenCoding5385_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5385_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6495[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6496, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6534, x64Parser::tokenBranches6534 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5385_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5385(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 451; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5385_16; - operand.values[17] = tokenCoding5385_17; - operand.values[19] = tokenCoding5385_19; -} -x64Token x64Parser::tokenBranches5379[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5380, - }, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5385, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5373[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5374}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5379}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5372[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5373}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5371[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5372}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5390_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6490[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5390_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6489[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5390_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5390(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5390_16; - operand.values[17] = tokenCoding5390_17; - operand.values[19] = tokenCoding5390_19; -} -x64Token x64Parser::tokenBranches5389[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5390, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5395_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5395_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5395_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5395(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5395_16; - operand.values[17] = tokenCoding5395_17; - operand.values[19] = tokenCoding5395_19; -} -x64Token x64Parser::tokenBranches5394[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5395, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5400_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5400_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6549_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5400_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5400(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5400_16; - operand.values[17] = tokenCoding5400_17; - operand.values[19] = tokenCoding5400_19; +void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6549_16; + operand.values[17] = tokenCoding6549_17; + operand.values[18] = tokenCoding6549_18; + operand.values[19] = tokenCoding6549_19; } -Coding x64Parser::tokenCoding5405_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6548[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6549, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5405_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5405_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5405(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5405_16; - operand.values[17] = tokenCoding5405_17; - operand.values[19] = tokenCoding5405_19; -} -x64Token x64Parser::tokenBranches5399[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5400, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5405, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5388[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5389}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5394}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5399}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5387[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5388}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5386[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5387}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5410_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5410_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5410_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5410(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5410_16; - operand.values[17] = tokenCoding5410_17; - operand.values[19] = tokenCoding5410_19; -} -x64Token x64Parser::tokenBranches5409[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5410, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5415_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6551_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5415_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6551_16; + operand.values[17] = tokenCoding6551_17; + operand.values[18] = tokenCoding6551_18; + operand.values[19] = tokenCoding6551_19; +} +x64Token x64Parser::tokenBranches6550[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6551, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5415_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5415(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5415_16; - operand.values[17] = tokenCoding5415_17; - operand.values[19] = tokenCoding5415_19; -} -x64Token x64Parser::tokenBranches5414[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5415, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5420_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5420_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5420_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5420(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5420_16; - operand.values[17] = tokenCoding5420_17; - operand.values[19] = tokenCoding5420_19; -} -x64Token x64Parser::tokenBranches5419[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5420, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5425_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5425_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6553_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5425_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5425(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5425_16; - operand.values[17] = tokenCoding5425_17; - operand.values[19] = tokenCoding5425_19; +void x64Parser::TokenFunc6553(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6553_16; + operand.values[17] = tokenCoding6553_17; + operand.values[18] = tokenCoding6553_18; + operand.values[19] = tokenCoding6553_19; } -Coding x64Parser::tokenCoding5430_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6552[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6553, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5430_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5430_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5430(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5430_16; - operand.values[17] = tokenCoding5430_17; - operand.values[19] = tokenCoding5430_19; -} -x64Token x64Parser::tokenBranches5424[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5425, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5430, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5408[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5409}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5414}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5419}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5424}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5407[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5408}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5406[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5407}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5434_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5434_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5434_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 128, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5434(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5434_16; - operand.values[17] = tokenCoding5434_17; - operand.values[19] = tokenCoding5434_19; -} -x64Token x64Parser::tokenBranches5433[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5434, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5432[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5433}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5431[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5432}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5438_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6555_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6555_16; + operand.values[17] = tokenCoding6555_17; + operand.values[18] = tokenCoding6555_18; + operand.values[19] = tokenCoding6555_19; +} +x64Token x64Parser::tokenBranches6554[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6472[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6473, x64Parser::tokenBranches6473 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6481, x64Parser::tokenBranches6481 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6489, x64Parser::tokenBranches6489 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 514; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6559[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6560, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6575(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 518; +} +x64Token x64Parser::tokenBranches6558[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6575, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6557[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 515; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6563[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6564, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 519; +} +x64Token x64Parser::tokenBranches6562[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6578, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 516; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6567[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6568, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 520; +} +x64Token x64Parser::tokenBranches6566[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 517; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6571[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6572, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5438_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 521; +} +x64Token x64Parser::tokenBranches6570[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5438_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5438(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5438_16; - operand.values[17] = tokenCoding5438_17; - operand.values[19] = tokenCoding5438_19; -} -x64Token x64Parser::tokenBranches5437[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5438, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5442_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5442_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6556[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5442_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5442(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 450; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5442_16; - operand.values[17] = tokenCoding5442_17; - operand.values[19] = tokenCoding5442_19; +void x64Parser::TokenFunc6593(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 522; } -Coding x64Parser::tokenCoding5446_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6592[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6593, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5446_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6591[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5446_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5446(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 451; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5446_16; - operand.values[17] = tokenCoding5446_17; - operand.values[19] = tokenCoding5446_19; -} -x64Token x64Parser::tokenBranches5441[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5442, - }, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5446, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5436[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5437}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5441}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5435[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5436}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5450_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6590[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5450_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6609(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 524; +} +x64Token x64Parser::tokenBranches6608[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6609, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5450_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5450(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5450_16; - operand.values[17] = tokenCoding5450_17; - operand.values[19] = tokenCoding5450_19; -} -x64Token x64Parser::tokenBranches5449[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5450, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5454_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6607[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5454_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6606[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5454_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5454(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5454_16; - operand.values[17] = tokenCoding5454_17; - operand.values[19] = tokenCoding5454_19; -} -x64Token x64Parser::tokenBranches5453[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5454, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5458_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6589[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5458_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6588[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5458_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5458(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 452; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5458_16; - operand.values[17] = tokenCoding5458_17; - operand.values[19] = tokenCoding5458_19; -} -Coding x64Parser::tokenCoding5462_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6587[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5462_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6601(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 523; +} +x64Token x64Parser::tokenBranches6600[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6601, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5462_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5462(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 453; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5462_16; - operand.values[17] = tokenCoding5462_17; - operand.values[19] = tokenCoding5462_19; -} -x64Token x64Parser::tokenBranches5457[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5458, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5462, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5448[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5449}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5453}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5457}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5447[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5448}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5466_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6599[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5466_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6598[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5466_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5466(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5466_16; - operand.values[17] = tokenCoding5466_17; - operand.values[19] = tokenCoding5466_19; -} -x64Token x64Parser::tokenBranches5465[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5466, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5470_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6617(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 525; +} +x64Token x64Parser::tokenBranches6616[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6617, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5470_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6615[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5470_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5470(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5470_16; - operand.values[17] = tokenCoding5470_17; - operand.values[19] = tokenCoding5470_19; -} -x64Token x64Parser::tokenBranches5469[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5470, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5474_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6614[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5474_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6631(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 527; +} +x64Token x64Parser::tokenBranches6630[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6631, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5474_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5474(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5474_16; - operand.values[17] = tokenCoding5474_17; - operand.values[19] = tokenCoding5474_19; -} -x64Token x64Parser::tokenBranches5473[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5474, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5478_16[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5478_17[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6628[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5478_19[] = { - {CODING_NAME("signedimm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 131, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5478(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 454; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5478_16; - operand.values[17] = tokenCoding5478_17; - operand.values[19] = tokenCoding5478_19; -} -Coding x64Parser::tokenCoding5482_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6597[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5482_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6596[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5482_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 129, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5482(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 455; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5482_16; - operand.values[17] = tokenCoding5482_17; - operand.values[19] = tokenCoding5482_19; -} -x64Token x64Parser::tokenBranches5477[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5478, - }, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5482, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5464[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5465}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5469}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5473}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5477}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5463[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5464}, {x64Token::EOT}}; -void x64Parser::TokenFunc5326(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5330(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5334(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5338(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5342(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches5309[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches5310}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5314}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5318}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5322}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc5326, x64Parser::tokenBranches5326}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc5330, x64Parser::tokenBranches5330}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5334, x64Parser::tokenBranches5334}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5338, x64Parser::tokenBranches5338}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5342, x64Parser::tokenBranches5342}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5346}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5354}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5358}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5362}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5366}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5371}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5386}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5406}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5431}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5435}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5447}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5463}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5488_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6622[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5488_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6621[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5488_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5488(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 456; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5488_16; - operand.values[17] = tokenCoding5488_17; - operand.values[19] = tokenCoding5488_19; -} -x64Token x64Parser::tokenBranches5487[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5488, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5502_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6620[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6595[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6596, x64Parser::tokenBranches6596 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6586[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5502_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5502(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5502_16; - operand.values[17] = tokenCoding5502_17; - operand.values[18] = tokenCoding5502_18; - operand.values[19] = tokenCoding5502_19; -} -x64Token x64Parser::tokenBranches5486[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5487}, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5502, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5485[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5486}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5484[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5485}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5493_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6639(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 528; +} +x64Token x64Parser::tokenBranches6638[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6639, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5493_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6637[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5493_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5493(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 457; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5493_16; - operand.values[17] = tokenCoding5493_17; - operand.values[19] = tokenCoding5493_19; -} -x64Token x64Parser::tokenBranches5492[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5493, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5506_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6636[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6655(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 530; +} +x64Token x64Parser::tokenBranches6654[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6655, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6653[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5506_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5506(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5506_16; - operand.values[17] = tokenCoding5506_17; - operand.values[18] = tokenCoding5506_18; - operand.values[19] = tokenCoding5506_19; -} -x64Token x64Parser::tokenBranches5491[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5492}, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5506, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5490[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5491}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5489[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5490}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5498_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6652[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5498_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6635[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5498_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5498(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 458; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5498_16; - operand.values[17] = tokenCoding5498_17; - operand.values[19] = tokenCoding5498_19; -} -x64Token x64Parser::tokenBranches5497[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5498, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5510_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6634[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6633[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6647(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 529; +} +x64Token x64Parser::tokenBranches6646[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6647, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5510_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5510(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5510_16; - operand.values[17] = tokenCoding5510_17; - operand.values[18] = tokenCoding5510_18; - operand.values[19] = tokenCoding5510_19; -} -x64Token x64Parser::tokenBranches5496[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5497}, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5510, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5495[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5496}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5494[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5495}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5483[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5484}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5489}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5494}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5520_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5520_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6644[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5520_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5520(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5520_16; - operand.values[17] = tokenCoding5520_17; - operand.values[19] = tokenCoding5520_19; -} -x64Token x64Parser::tokenBranches5519[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5520, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5522_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6663(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 531; +} +x64Token x64Parser::tokenBranches6662[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6663, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5522_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6661[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5522_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5522(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5522_16; - operand.values[17] = tokenCoding5522_17; - operand.values[19] = tokenCoding5522_19; -} -x64Token x64Parser::tokenBranches5521[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5522, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5524_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6660[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5524_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6677(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 533; +} +x64Token x64Parser::tokenBranches6676[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6677, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5524_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5524(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5524_16; - operand.values[17] = tokenCoding5524_17; - operand.values[19] = tokenCoding5524_19; -} -x64Token x64Parser::tokenBranches5523[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5524, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5526_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6675[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5526_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6674[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5526_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5526(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5526_16; - operand.values[17] = tokenCoding5526_17; - operand.values[19] = tokenCoding5526_19; -} -x64Token x64Parser::tokenBranches5525[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5526, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5512_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6643[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5512_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6642[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5512_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5512(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5512_16; - operand.values[17] = tokenCoding5512_17; - operand.values[19] = tokenCoding5512_19; -} -void x64Parser::TokenFunc5513(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 459; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5514(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 460; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5515(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 461; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 532; } -Coding x64Parser::tokenCoding5516_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6668[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5516_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6667[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5516_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6666[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5516(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5516_16; - operand.values[17] = tokenCoding5516_17; - operand.values[19] = tokenCoding5516_19; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -Coding x64Parser::tokenCoding5517_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5517_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6641[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6642, x64Parser::tokenBranches6642 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5517_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6632[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5517(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6685(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5517_16; - operand.values[17] = tokenCoding5517_17; - operand.values[19] = tokenCoding5517_19; + operand.operandCoding = 534; } -Coding x64Parser::tokenCoding5518_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5518_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6684[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6685, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5518_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5518(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5518_16; - operand.values[17] = tokenCoding5518_17; - operand.values[19] = tokenCoding5518_19; -} -x64Token x64Parser::tokenBranches5511[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5512, - }, - { - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5513, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5514, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5515, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5516, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5517, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5518, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5519}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5521}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5523}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5525}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5533_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6683[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5533_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6682[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5533_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5533(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5533_16; - operand.values[17] = tokenCoding5533_17; - operand.values[19] = tokenCoding5533_19; -} -x64Token x64Parser::tokenBranches5532[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5533, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5535_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6701(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 536; +} +x64Token x64Parser::tokenBranches6700[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6701, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5535_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6699[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5535_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5535(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5535_16; - operand.values[17] = tokenCoding5535_17; - operand.values[19] = tokenCoding5535_19; -} -x64Token x64Parser::tokenBranches5534[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5535, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5537_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6698[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5537_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6681[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5537_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5537(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5537_16; - operand.values[17] = tokenCoding5537_17; - operand.values[19] = tokenCoding5537_19; -} -x64Token x64Parser::tokenBranches5536[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5537, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5539_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6680[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5539_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6679[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5539_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5539(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5539_16; - operand.values[17] = tokenCoding5539_17; - operand.values[19] = tokenCoding5539_19; -} -x64Token x64Parser::tokenBranches5538[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5539, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5528_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6693(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 535; +} +x64Token x64Parser::tokenBranches6692[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6693, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5528_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6691[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5528_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6690[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5528(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6709(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5528_16; - operand.values[17] = tokenCoding5528_17; - operand.values[19] = tokenCoding5528_19; + operand.operandCoding = 537; } -Coding x64Parser::tokenCoding5529_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6708[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6709, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5529_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6707[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5529_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6706[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5529(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6723(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5529_16; - operand.values[17] = tokenCoding5529_17; - operand.values[19] = tokenCoding5529_19; + operand.operandCoding = 539; } -Coding x64Parser::tokenCoding5530_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6722[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6723, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5530_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6721[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5530_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6720[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6689[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6688[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5530(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5530_16; - operand.values[17] = tokenCoding5530_17; - operand.values[19] = tokenCoding5530_19; + operand.operandCoding = 538; } -Coding x64Parser::tokenCoding5531_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6714[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5531_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6713[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5531_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5531(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5531_16; - operand.values[17] = tokenCoding5531_17; - operand.values[19] = tokenCoding5531_19; -} -x64Token x64Parser::tokenBranches5527[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5528, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5529, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5530, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5531, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5532}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5534}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5536}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5538}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5543(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5542[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc5543, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5541[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5542}, {x64Token::EOT}}; -void x64Parser::TokenFunc5546(x64Operand& operand, int tokenPos) { operand.operandCoding = 463; } -x64Token x64Parser::tokenBranches5545[] = {{ - x64Token::REGISTER, - 99, - 1, - 0, - NULL, - &x64Parser::TokenFunc5546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5544[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5545}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5549_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6712[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5549_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6687[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6688, x64Parser::tokenBranches6688 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6678[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6585[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 540; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6729[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6730, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6728[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5549_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5549(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5549_16; - operand.values[17] = tokenCoding5549_17; - operand.values[19] = tokenCoding5549_19; -} -x64Token x64Parser::tokenBranches5548[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5549, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5551_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5551_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5551_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5551_16; - operand.values[17] = tokenCoding5551_17; - operand.values[19] = tokenCoding5551_19; -} -x64Token x64Parser::tokenBranches5550[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5551, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5544(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5540[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches5541}, - {x64Token::REGISTERCLASS, 20, 1, 0, NULL, &x64Parser::TokenFunc5544, x64Parser::tokenBranches5544}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5548}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5550}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5555(x64Operand& operand, int tokenPos) { operand.operandCoding = 439; } -x64Token x64Parser::tokenBranches5554[] = {{ - x64Token::REGISTER, - 99, - 1, - 0, - NULL, - &x64Parser::TokenFunc5555, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5553[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5554}, {x64Token::EOT}}; -void x64Parser::TokenFunc5553(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 439; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -void x64Parser::TokenFunc5557(x64Operand& operand, int tokenPos) { operand.operandCoding = 464; } -x64Token x64Parser::tokenBranches5552[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL, &x64Parser::TokenFunc5553, x64Parser::tokenBranches5553}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5557, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5560_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5560_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6736_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6736_16; + operand.values[17] = tokenCoding6736_17; + operand.values[18] = tokenCoding6736_18; + operand.values[19] = tokenCoding6736_19; +} +x64Token x64Parser::tokenBranches6735[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6736, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6740(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 541; +} +x64Token x64Parser::tokenBranches6739[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6740, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 542; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6747[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6748, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 543; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6749[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6750, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 544; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6760[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6761, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 545; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6765[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6766, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6759[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6758[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5560_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5560(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5560_16; - operand.values[17] = tokenCoding5560_17; - operand.values[19] = tokenCoding5560_19; -} -x64Token x64Parser::tokenBranches5559[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5560, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5562_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5562_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5562_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5562(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5562_16; - operand.values[17] = tokenCoding5562_17; - operand.values[19] = tokenCoding5562_19; -} -x64Token x64Parser::tokenBranches5561[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5562, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5558[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5559}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5561}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5565_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5565_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5565(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5565_16; - operand.values[17] = tokenCoding5565_17; -} -x64Token x64Parser::tokenBranches5564[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5565, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5563[] = {{x64Token::TOKEN, 12, 0, 1, NULL, NULL, x64Parser::tokenBranches5564}, {x64Token::EOT}}; -void x64Parser::TokenFunc5568(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 465; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5567[] = {{ - x64Token::NUMBER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5568, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5570(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 466; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5572(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 467; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5569[] = {{ - x64Token::NUMBER, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc5570, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5573(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 466; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5574(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 467; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5566[] = {{x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches5567}, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5569}, - { - x64Token::NUMBER, - 11, - 1, - 0, - NULL, - &x64Parser::TokenFunc5573, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5574, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5579_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6775_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5579_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6775(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6775_16; + operand.values[17] = tokenCoding6775_17; + operand.values[18] = tokenCoding6775_18; + operand.values[19] = tokenCoding6775_19; +} +x64Token x64Parser::tokenBranches6774[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6775, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5579_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5579_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5579(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5579_16; - operand.values[17] = tokenCoding5579_17; - operand.values[18] = tokenCoding5579_18; - operand.values[19] = tokenCoding5579_19; -} -x64Token x64Parser::tokenBranches5578[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5579, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5577[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5578}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5576[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5577}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5583_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6778_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6778_16; + operand.values[17] = tokenCoding6778_17; + operand.values[18] = tokenCoding6778_18; + operand.values[19] = tokenCoding6778_19; +} +x64Token x64Parser::tokenBranches6777[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::number; + operand.values[2]->val = operands.size(); + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 546; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 547; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6772_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5583_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5583(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5583_16; - operand.values[17] = tokenCoding5583_17; - operand.values[18] = tokenCoding5583_18; - operand.values[19] = tokenCoding5583_19; -} -x64Token x64Parser::tokenBranches5582[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5583, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5581[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5582}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5580[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5581}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5587_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6772_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5587_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5587(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5587_16; - operand.values[17] = tokenCoding5587_17; - operand.values[18] = tokenCoding5587_18; - operand.values[19] = tokenCoding5587_19; -} -x64Token x64Parser::tokenBranches5586[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5587, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5585[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5586}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5584[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5585}, {x64Token::EOT}}; -void x64Parser::TokenFunc5576(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5580(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5584(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6772_16; + operand.values[17] = tokenCoding6772_17; + operand.values[18] = tokenCoding6772_18; + operand.values[19] = tokenCoding6772_19; } -x64Token x64Parser::tokenBranches5575[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5576, x64Parser::tokenBranches5576}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5580, x64Parser::tokenBranches5580}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5584, x64Parser::tokenBranches5584}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5590_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5590_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6757[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6758, x64Parser::tokenBranches6758 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6768, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6770, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6772, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 548; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6779[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6780, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 549; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 550; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6781[] = { + {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6782, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5590_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5590_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 4, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5590(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5590_16; - operand.values[17] = tokenCoding5590_17; - operand.values[18] = tokenCoding5590_18; - operand.values[19] = tokenCoding5590_19; -} -x64Token x64Parser::tokenBranches5589[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5590, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5588[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5589}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5604_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6792_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5604_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5604(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5604_16; - operand.values[17] = tokenCoding5604_17; - operand.values[18] = tokenCoding5604_18; - operand.values[19] = tokenCoding5604_19; -} -x64Token x64Parser::tokenBranches5603[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5604, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5594_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6792_16; + operand.values[17] = tokenCoding6792_17; + operand.values[18] = tokenCoding6792_18; + operand.values[19] = tokenCoding6792_19; +} +x64Token x64Parser::tokenBranches6791[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6792, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5594_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5594_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5594_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5594(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5594_16; - operand.values[17] = tokenCoding5594_17; - operand.values[18] = tokenCoding5594_18; - operand.values[19] = tokenCoding5594_19; -} -x64Token x64Parser::tokenBranches5593[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5594, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5603}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5592[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5593}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5608_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5608_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6794_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5608_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6794_16; + operand.values[17] = tokenCoding6794_17; + operand.values[18] = tokenCoding6794_18; + operand.values[19] = tokenCoding6794_19; +} +x64Token x64Parser::tokenBranches6793[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6794, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5608_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5608(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5608_16; - operand.values[17] = tokenCoding5608_17; - operand.values[18] = tokenCoding5608_18; - operand.values[19] = tokenCoding5608_19; -} -x64Token x64Parser::tokenBranches5607[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5608, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5612_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5612_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5612(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5612_16; - operand.values[17] = tokenCoding5612_17; - operand.values[18] = tokenCoding5612_18; - operand.values[19] = tokenCoding5612_19; -} -x64Token x64Parser::tokenBranches5611[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5612, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5597_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6796_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6796_16; + operand.values[17] = tokenCoding6796_17; + operand.values[18] = tokenCoding6796_18; + operand.values[19] = tokenCoding6796_19; +} +x64Token x64Parser::tokenBranches6795[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 549; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 550; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding6787_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5597_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6787_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5597(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6787(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5597_16; - operand.values[17] = tokenCoding5597_17; - operand.values[18] = tokenCoding5597_18; - operand.values[19] = tokenCoding5597_19; + operand.values[16] = tokenCoding6787_16; + operand.values[17] = tokenCoding6787_17; + operand.values[18] = tokenCoding6787_18; + operand.values[19] = tokenCoding6787_19; } -Coding x64Parser::tokenCoding5600_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5600_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5600(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5600_16; - operand.values[17] = tokenCoding5600_17; - operand.values[18] = tokenCoding5600_18; - operand.values[19] = tokenCoding5600_19; -} -x64Token x64Parser::tokenBranches5596[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5597, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5600, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5607}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5611}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5595[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5596}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5625_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6788_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6788_16; + operand.values[17] = tokenCoding6788_17; + operand.values[18] = tokenCoding6788_18; + operand.values[19] = tokenCoding6788_19; +} +Coding x64Parser::tokenCoding6789_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5625_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5625(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5625_16; - operand.values[17] = tokenCoding5625_17; - operand.values[18] = tokenCoding5625_18; - operand.values[19] = tokenCoding5625_19; -} -x64Token x64Parser::tokenBranches5624[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5625, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5629_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6789_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6789(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6789_16; + operand.values[17] = tokenCoding6789_17; + operand.values[18] = tokenCoding6789_18; + operand.values[19] = tokenCoding6789_19; +} +Coding x64Parser::tokenCoding6790_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5629_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5629(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5629_16; - operand.values[17] = tokenCoding5629_17; - operand.values[18] = tokenCoding5629_18; - operand.values[19] = tokenCoding5629_19; -} -x64Token x64Parser::tokenBranches5628[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5629, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5633_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5633_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5633_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6790_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6790_16; + operand.values[17] = tokenCoding6790_17; + operand.values[18] = tokenCoding6790_18; + operand.values[19] = tokenCoding6790_19; +} +x64Token x64Parser::tokenBranches6756[] = { + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757 }, + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6785, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6786, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6787, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6788, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6789, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6790, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5633_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5633(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5633_16; - operand.values[17] = tokenCoding5633_17; - operand.values[18] = tokenCoding5633_18; - operand.values[19] = tokenCoding5633_19; -} -x64Token x64Parser::tokenBranches5632[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5633, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5615_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5615_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6830_19[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5615(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6830(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5615_16; - operand.values[17] = tokenCoding5615_17; - operand.values[18] = tokenCoding5615_18; - operand.values[19] = tokenCoding5615_19; + operand.values[16] = tokenCoding6830_16; + operand.values[17] = tokenCoding6830_17; + operand.values[18] = tokenCoding6830_18; + operand.values[19] = tokenCoding6830_19; } -Coding x64Parser::tokenCoding5618_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6829[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6830, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6837(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 551; +} +x64Token x64Parser::tokenBranches6836[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6837, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 553; +} +x64Token x64Parser::tokenBranches6848[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5618_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6835[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6834[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5618(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc6843(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5618_16; - operand.values[17] = tokenCoding5618_17; - operand.values[18] = tokenCoding5618_18; - operand.values[19] = tokenCoding5618_19; + operand.operandCoding = 552; } -Coding x64Parser::tokenCoding5621_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5621_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6842[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6843, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5621_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6855(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 554; +} +x64Token x64Parser::tokenBranches6854[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6855, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5621_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5621(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5621_16; - operand.values[17] = tokenCoding5621_17; - operand.values[18] = tokenCoding5621_18; - operand.values[19] = tokenCoding5621_19; -} -x64Token x64Parser::tokenBranches5614[] = {{ - x64Token::ADDRESSCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc5615, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5618, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5621, - }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5624}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5628}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5632}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5613[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5614}, {x64Token::EOT}}; -void x64Parser::TokenFunc5592(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5595(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5613(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches5591[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5592, x64Parser::tokenBranches5592}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5595, x64Parser::tokenBranches5595}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5613, x64Parser::tokenBranches5613}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5637_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6864[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5637_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6841[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5637_19[] = { - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5637(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5637_16; - operand.values[17] = tokenCoding5637_17; - operand.values[19] = tokenCoding5637_19; +x64Token x64Parser::tokenBranches6840[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6859(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 555; } -Coding x64Parser::tokenCoding5640_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6858[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6859, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5640_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6840(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6833[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6840, x64Parser::tokenBranches6840 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5640_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5640(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5640_16; - operand.values[17] = tokenCoding5640_17; - operand.values[19] = tokenCoding5640_19; +x64Token x64Parser::tokenBranches6832[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6871(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 557; } -Coding x64Parser::tokenCoding5643_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6870[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6871, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5643_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 559; +} +x64Token x64Parser::tokenBranches6882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5643_19[] = { - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5643(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5643_16; - operand.values[17] = tokenCoding5643_17; - operand.values[19] = tokenCoding5643_19; -} -x64Token x64Parser::tokenBranches5636[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5637, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5640, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5643, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5635[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5636}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5648_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6869[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5648_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6868[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5648_19[] = { - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5648(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5648_16; - operand.values[17] = tokenCoding5648_17; - operand.values[19] = tokenCoding5648_19; +void x64Parser::TokenFunc6877(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 558; } -Coding x64Parser::tokenCoding5653_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6876[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6877, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5653_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6889(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 560; +} +x64Token x64Parser::tokenBranches6888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6889, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5653_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5653(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5653_16; - operand.values[17] = tokenCoding5653_17; - operand.values[19] = tokenCoding5653_19; -} -x64Token x64Parser::tokenBranches5647[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5648, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5653, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5657_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 562; +} +x64Token x64Parser::tokenBranches6898[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5657_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6875[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5657_19[] = { - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 210, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5657(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5657_16; - operand.values[17] = tokenCoding5657_17; - operand.values[19] = tokenCoding5657_19; -} -x64Token x64Parser::tokenBranches5646[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5647}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5657, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5646}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5644[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5645}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5660_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6874[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5660_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6893(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 561; +} +x64Token x64Parser::tokenBranches6892[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6893, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5660_19[] = { - {CODING_NAME("one") Coding::stateFunc, 4}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5660(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5660_16; - operand.values[17] = tokenCoding5660_17; - operand.values[19] = tokenCoding5660_19; +void x64Parser::TokenFunc6874(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -Coding x64Parser::tokenCoding5663_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6867[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6874, x64Parser::tokenBranches6874 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5663_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6866[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5663_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5663(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5663_16; - operand.values[17] = tokenCoding5663_17; - operand.values[19] = tokenCoding5663_19; +void x64Parser::TokenFunc6905(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 563; } -Coding x64Parser::tokenCoding5666_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6904[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6905, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5666_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 565; +} +x64Token x64Parser::tokenBranches6916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5666_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5666(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5666_16; - operand.values[17] = tokenCoding5666_17; - operand.values[19] = tokenCoding5666_19; -} -x64Token x64Parser::tokenBranches5659[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5660, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5663, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5666, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5658[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5659}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5671_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6903[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5671_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6902[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5671_19[] = { - {CODING_NAME("one") Coding::stateFunc, 4}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5671(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5671_16; - operand.values[17] = tokenCoding5671_17; - operand.values[19] = tokenCoding5671_19; +void x64Parser::TokenFunc6911(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 564; } -Coding x64Parser::tokenCoding5676_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6910[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6911, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5676_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6923(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 566; +} +x64Token x64Parser::tokenBranches6922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6923, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5676_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5676(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5676_16; - operand.values[17] = tokenCoding5676_17; - operand.values[19] = tokenCoding5676_19; -} -x64Token x64Parser::tokenBranches5670[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5671, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5676, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5680_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 568; +} +x64Token x64Parser::tokenBranches6932[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5680_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6909[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5680_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5680(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5680_16; - operand.values[17] = tokenCoding5680_17; - operand.values[19] = tokenCoding5680_19; -} -x64Token x64Parser::tokenBranches5669[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5670}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5680, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5668[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5669}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5667[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5668}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5687_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6908[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5687_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6927(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 567; +} +x64Token x64Parser::tokenBranches6926[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6927, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5687_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5687(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5687_16; - operand.values[17] = tokenCoding5687_17; - operand.values[19] = tokenCoding5687_19; -} -x64Token x64Parser::tokenBranches5686[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5687, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5683_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6901[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6908, x64Parser::tokenBranches6908 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5683_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6900[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5683_19[] = { - {CODING_NAME("one") Coding::stateFunc, 5}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5683(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5683_16; - operand.values[17] = tokenCoding5683_17; - operand.values[19] = tokenCoding5683_19; +void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 569; } -Coding x64Parser::tokenCoding5690_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6938[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5690_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6937[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5690_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5690(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5690_16; - operand.values[17] = tokenCoding5690_17; - operand.values[19] = tokenCoding5690_19; -} -x64Token x64Parser::tokenBranches5682[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5683, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5686}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5690, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5681[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5682}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5695_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6936[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5695_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 570; +} +x64Token x64Parser::tokenBranches6944[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5695_19[] = { - {CODING_NAME("one") Coding::stateFunc, 5}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5695(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5695_16; - operand.values[17] = tokenCoding5695_17; - operand.values[19] = tokenCoding5695_19; +void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 572; } -Coding x64Parser::tokenCoding5700_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6954[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5700_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6943[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5700_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5700(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5700_16; - operand.values[17] = tokenCoding5700_17; - operand.values[19] = tokenCoding5700_19; -} -x64Token x64Parser::tokenBranches5694[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5695, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5700, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5704_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6942[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5704_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6949(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 571; +} +x64Token x64Parser::tokenBranches6948[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6949, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5704_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5704(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5704_16; - operand.values[17] = tokenCoding5704_17; - operand.values[19] = tokenCoding5704_19; -} -x64Token x64Parser::tokenBranches5693[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5694}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5704, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5692[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5693}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5691[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5692}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5711_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6935[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6942, x64Parser::tokenBranches6942 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6934[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6831[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6960(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 573; +} +x64Token x64Parser::tokenBranches6959[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6960, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 574; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6961[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6962, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 575; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6963[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6964, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 576; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6965[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6966, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 576; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6967[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 575; + operand.values[11] = new Coding[2]; + CleanupValues.push_back(operand.values[11]); + operand.values[11]->type = Coding::number; + operand.values[11]->val = operands.size(); + operand.values[11]->bits = 0; + operand.values[11]->field = 0; + operand.values[11]->unary = 0; + operand.values[11]->binary = 0; + operand.values[11][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6969[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5711_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5711_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5711(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5711_16; - operand.values[17] = tokenCoding5711_17; - operand.values[19] = tokenCoding5711_19; -} -x64Token x64Parser::tokenBranches5710[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5711, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5707_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5707_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6974_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5707_19[] = { - {CODING_NAME("one") Coding::stateFunc, 6}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5707(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5707_16; - operand.values[17] = tokenCoding5707_17; - operand.values[19] = tokenCoding5707_19; +Coding x64Parser::tokenCoding6974_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6974_16; + operand.values[17] = tokenCoding6974_17; + operand.values[18] = tokenCoding6974_18; + operand.values[19] = tokenCoding6974_19; } -Coding x64Parser::tokenCoding5714_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6973[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6974, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5714_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5714_19[] = { - {CODING_NAME("") Coding::stateFunc, 6}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5714(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5714_16; - operand.values[17] = tokenCoding5714_17; - operand.values[19] = tokenCoding5714_19; -} -x64Token x64Parser::tokenBranches5706[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5707, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5710}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5714, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5705[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5706}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5719_16[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5719_17[] = { - {CODING_NAME("one")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5719_19[] = { - {CODING_NAME("one") Coding::stateFunc, 6}, - {CODING_NAME("one")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5719(x64Operand& operand, int tokenPos) -{ - operand.values[25] = new Coding[2]; - CleanupValues.push_back(operand.values[25]); - operand.values[25]->type = Coding::number; - operand.values[25]->val = operands.size(); - operand.values[25]->bits = 0; - operand.values[25]->field = 0; - operand.values[25]->unary = 0; - operand.values[25]->binary = 0; - operand.values[25][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5719_16; - operand.values[17] = tokenCoding5719_17; - operand.values[19] = tokenCoding5719_19; -} -Coding x64Parser::tokenCoding5724_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6978_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5724_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6978(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6978_16; + operand.values[17] = tokenCoding6978_17; + operand.values[18] = tokenCoding6978_18; + operand.values[19] = tokenCoding6978_19; +} +x64Token x64Parser::tokenBranches6977[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6978, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5724_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5724(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5724_16; - operand.values[17] = tokenCoding5724_17; - operand.values[19] = tokenCoding5724_19; -} -x64Token x64Parser::tokenBranches5718[] = {{ - x64Token::NUMBER, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc5719, - }, - { - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5724, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5728_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6976[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5728_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5728_19[] = { - {CODING_NAME("") Coding::stateFunc, 6}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 211, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5728(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5728_16; - operand.values[17] = tokenCoding5728_17; - operand.values[19] = tokenCoding5728_19; -} -x64Token x64Parser::tokenBranches5717[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches5718}, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5728, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5716[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5717}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5715[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5716}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5634[] = {{x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches5635}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5644}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches5658}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5667}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches5681}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5691}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches5705}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5715}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5735_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6981_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5735_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5735(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5735_16; - operand.values[17] = tokenCoding5735_17; - operand.values[18] = tokenCoding5735_18; - operand.values[19] = tokenCoding5735_19; +void x64Parser::TokenFunc6981(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6981_16; + operand.values[17] = tokenCoding6981_17; + operand.values[18] = tokenCoding6981_18; + operand.values[19] = tokenCoding6981_19; } -Coding x64Parser::tokenCoding5741_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6980[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6981, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5741_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5741_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6979[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5741_19[] = { - {CODING_NAME("") Coding::stateFunc, 4}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5741(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5741_16; - operand.values[17] = tokenCoding5741_17; - operand.values[18] = tokenCoding5741_18; - operand.values[19] = tokenCoding5741_19; -} -x64Token x64Parser::tokenBranches5734[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5735, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5741, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5733[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5734}, {x64Token::EOT}}; -void x64Parser::TokenFunc5733(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5732[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc5733, x64Parser::tokenBranches5733}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5731[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5732}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5730[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5731}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5747_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5747_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5747(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5747_16; - operand.values[17] = tokenCoding5747_17; - operand.values[18] = tokenCoding5747_18; - operand.values[19] = tokenCoding5747_19; -} -Coding x64Parser::tokenCoding5753_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding6984_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5753_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6984_16; + operand.values[17] = tokenCoding6984_17; + operand.values[18] = tokenCoding6984_18; + operand.values[19] = tokenCoding6984_19; +} +x64Token x64Parser::tokenBranches6983[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5753_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6982[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5753_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5753(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5753_16; - operand.values[17] = tokenCoding5753_17; - operand.values[18] = tokenCoding5753_18; - operand.values[19] = tokenCoding5753_19; -} -x64Token x64Parser::tokenBranches5746[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5747, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5753, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5745[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5746}, {x64Token::EOT}}; -void x64Parser::TokenFunc5745(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 577; } -x64Token x64Parser::tokenBranches5744[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5745, x64Parser::tokenBranches5745}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5743[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5744}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5742[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches5743}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5759_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6989[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6990, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc6998(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 578; +} +x64Token x64Parser::tokenBranches6997[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6998, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7012(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 580; +} +x64Token x64Parser::tokenBranches7011[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7012, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5759_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5759(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5759_16; - operand.values[17] = tokenCoding5759_17; - operand.values[18] = tokenCoding5759_18; - operand.values[19] = tokenCoding5759_19; +void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5765_16[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6996[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6997, x64Parser::tokenBranches6997 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7011, x64Parser::tokenBranches7011 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6995[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 579; +} +x64Token x64Parser::tokenBranches7003[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches6988[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6989, x64Parser::tokenBranches6989 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_17[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6987[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_18[] = { - {CODING_NAME("")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches6986[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5765_19[] = { - {CODING_NAME("") Coding::stateFunc, 5}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5765(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5765_16; - operand.values[17] = tokenCoding5765_17; - operand.values[18] = tokenCoding5765_18; - operand.values[19] = tokenCoding5765_19; -} -x64Token x64Parser::tokenBranches5758[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5759, - }, - { - x64Token::REGISTER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5765, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5757[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5758}, {x64Token::EOT}}; -void x64Parser::TokenFunc5757(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +x64Token x64Parser::tokenBranches6985[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches5756[] = { - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5757, x64Parser::tokenBranches5757}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5755[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5756}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5754[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5755}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5729[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5730}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5742}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches5754}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5767_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7017[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5767_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5767(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5767_16; - operand.values[17] = tokenCoding5767_17; -} -x64Token x64Parser::tokenBranches5766[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5767, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5771_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7026(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 582; +} +x64Token x64Parser::tokenBranches7025[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7026, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5771_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7040(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 584; +} +x64Token x64Parser::tokenBranches7039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7040, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5771_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5771(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5771_16; - operand.values[17] = tokenCoding5771_17; - operand.values[18] = tokenCoding5771_18; -} -x64Token x64Parser::tokenBranches5770[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5771, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5769[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5770}, {x64Token::EOT}}; -void x64Parser::TokenFunc5769(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5768[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5769, x64Parser::tokenBranches5769}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5775_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7024[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7025, x64Parser::tokenBranches7025 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7039, x64Parser::tokenBranches7039 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7023[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 583; +} +x64Token x64Parser::tokenBranches7031[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7016[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7015[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7014[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5775_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5775(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5775_16; - operand.values[17] = tokenCoding5775_17; - operand.values[18] = tokenCoding5775_18; - operand.values[19] = tokenCoding5775_19; -} -x64Token x64Parser::tokenBranches5774[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5775, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5773[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5774}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5778_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7013[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 585; +} +x64Token x64Parser::tokenBranches7045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7054(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 586; +} +x64Token x64Parser::tokenBranches7053[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7054, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5778_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5778(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5778_16; - operand.values[17] = tokenCoding5778_17; - operand.values[18] = tokenCoding5778_18; - operand.values[19] = tokenCoding5778_19; -} -x64Token x64Parser::tokenBranches5777[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5778, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5776[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5777}, {x64Token::EOT}}; -void x64Parser::TokenFunc5773(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7068(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches5772[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5773, x64Parser::tokenBranches5773}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5776}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5782_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7068, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5782_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7052[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7053, x64Parser::tokenBranches7053 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7067, x64Parser::tokenBranches7067 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7051[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 587; +} +x64Token x64Parser::tokenBranches7059[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7044[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7043[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7042[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7041[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 589; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7092_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5782_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5782_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5782(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5782_16; - operand.values[17] = tokenCoding5782_17; - operand.values[18] = tokenCoding5782_18; - operand.values[19] = tokenCoding5782_19; -} -x64Token x64Parser::tokenBranches5781[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5782, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5780[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5781}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5785_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7092_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7092(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7092_16; + operand.values[17] = tokenCoding7092_17; + operand.values[18] = tokenCoding7092_18; + operand.values[19] = tokenCoding7092_19; +} +x64Token x64Parser::tokenBranches7071[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7072, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7092, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7070[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7069[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 590; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7096_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7096_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5785_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5785(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5785_16; - operand.values[17] = tokenCoding5785_17; - operand.values[18] = tokenCoding5785_18; - operand.values[19] = tokenCoding5785_19; -} -x64Token x64Parser::tokenBranches5784[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5785, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5783[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5784}, {x64Token::EOT}}; -void x64Parser::TokenFunc5780(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7096_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7096_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7096_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7096(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7096_16; + operand.values[17] = tokenCoding7096_17; + operand.values[23] = tokenCoding7096_23; + operand.values[18] = tokenCoding7096_18; + operand.values[19] = tokenCoding7096_19; +} +x64Token x64Parser::tokenBranches7075[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7076, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7096, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7074[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7073[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 591; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5779[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5780, x64Parser::tokenBranches5780}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5783}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5789_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5789_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5789(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5789_16; - operand.values[17] = tokenCoding5789_17; - operand.values[18] = tokenCoding5789_18; - operand.values[19] = tokenCoding5789_19; -} -x64Token x64Parser::tokenBranches5788[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5789, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5787[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5788}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5792_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7100_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7100(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7100_16; + operand.values[17] = tokenCoding7100_17; + operand.values[18] = tokenCoding7100_18; + operand.values[19] = tokenCoding7100_19; +} +x64Token x64Parser::tokenBranches7079[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7080, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7100, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7078[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7077[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 592; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7104_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7104_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7104_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5792_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5792(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5792_16; - operand.values[17] = tokenCoding5792_17; - operand.values[18] = tokenCoding5792_18; - operand.values[19] = tokenCoding5792_19; -} -x64Token x64Parser::tokenBranches5791[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5792, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5790[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5791}, {x64Token::EOT}}; -void x64Parser::TokenFunc5787(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7104_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7104(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7104_16; + operand.values[17] = tokenCoding7104_17; + operand.values[18] = tokenCoding7104_18; + operand.values[19] = tokenCoding7104_19; +} +x64Token x64Parser::tokenBranches7083[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7084, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7104, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7082[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7081[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 593; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5786[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5787, x64Parser::tokenBranches5787}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5790}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5796_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5796_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5796_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5796(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5796_16; - operand.values[17] = tokenCoding5796_17; - operand.values[18] = tokenCoding5796_18; -} -x64Token x64Parser::tokenBranches5795[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5796, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5794[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5795}, {x64Token::EOT}}; -void x64Parser::TokenFunc5794(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5793[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5794, x64Parser::tokenBranches5794}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5800_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5800_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7108_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5800_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5800(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5800_16; - operand.values[17] = tokenCoding5800_17; - operand.values[18] = tokenCoding5800_18; -} -x64Token x64Parser::tokenBranches5799[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5800, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5798[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5799}, {x64Token::EOT}}; -void x64Parser::TokenFunc5798(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7108(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7108_16; + operand.values[17] = tokenCoding7108_17; + operand.values[18] = tokenCoding7108_18; + operand.values[19] = tokenCoding7108_19; } -x64Token x64Parser::tokenBranches5797[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5798, x64Parser::tokenBranches5798}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5804_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7087[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7088, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7108, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5804_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7086[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5804_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5804(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5804_16; - operand.values[17] = tokenCoding5804_17; - operand.values[18] = tokenCoding5804_18; -} -x64Token x64Parser::tokenBranches5803[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc5804, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5802[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5803}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5807_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7085[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5807_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5807_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5807(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5807_16; - operand.values[17] = tokenCoding5807_17; - operand.values[18] = tokenCoding5807_18; -} -x64Token x64Parser::tokenBranches5806[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc5807, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5805[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5806}, {x64Token::EOT}}; -void x64Parser::TokenFunc5802(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5805(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5801[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc5802, x64Parser::tokenBranches5802}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc5805, x64Parser::tokenBranches5805}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5812_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5812_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5812_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5812(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5812_16; - operand.values[17] = tokenCoding5812_17; - operand.values[18] = tokenCoding5812_18; -} -x64Token x64Parser::tokenBranches5811[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc5812, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5816_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7113_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7113_16; + operand.values[17] = tokenCoding7113_17; + operand.values[18] = tokenCoding7113_18; + operand.values[19] = tokenCoding7113_19; +} +x64Token x64Parser::tokenBranches7112[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7113, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7111[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7110[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7109[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5816_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5816_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5816(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5816_16; - operand.values[17] = tokenCoding5816_17; - operand.values[18] = tokenCoding5816_18; -} -x64Token x64Parser::tokenBranches5815[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5816, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5810[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5811}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5815}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5809[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5810}, {x64Token::EOT}}; -void x64Parser::TokenFunc5809(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5808[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5809, x64Parser::tokenBranches5809}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5820_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5820_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5820_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7118_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7118_16; + operand.values[17] = tokenCoding7118_17; + operand.values[18] = tokenCoding7118_18; + operand.values[19] = tokenCoding7118_19; +} +x64Token x64Parser::tokenBranches7117[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7118, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7116[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7115[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7114[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5820_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5820(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5820_16; - operand.values[17] = tokenCoding5820_17; - operand.values[23] = tokenCoding5820_23; - operand.values[18] = tokenCoding5820_18; -} -x64Token x64Parser::tokenBranches5819[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5820, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5818[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5819}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5823_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5823_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5823(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5823_16; - operand.values[17] = tokenCoding5823_17; - operand.values[23] = tokenCoding5823_23; - operand.values[18] = tokenCoding5823_18; -} -x64Token x64Parser::tokenBranches5822[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5823, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5821[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5822}, {x64Token::EOT}}; -void x64Parser::TokenFunc5818(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5821(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5817[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5818, x64Parser::tokenBranches5818}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5821, x64Parser::tokenBranches5821}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5829_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7123_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7123_16; + operand.values[17] = tokenCoding7123_17; + operand.values[18] = tokenCoding7123_18; + operand.values[19] = tokenCoding7123_19; +} +x64Token x64Parser::tokenBranches7122[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7123, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7121[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7120[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7119[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5829_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_16[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5829_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5829(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5829_16; - operand.values[17] = tokenCoding5829_17; - operand.values[18] = tokenCoding5829_18; -} -x64Token x64Parser::tokenBranches5828[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5829, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5827[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5828}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5826[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5827}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5825[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5826}, {x64Token::EOT}}; -void x64Parser::TokenFunc5825(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5824[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5825, x64Parser::tokenBranches5825}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5833_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_17[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7128_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding7128_16; + operand.values[17] = tokenCoding7128_17; + operand.values[18] = tokenCoding7128_18; + operand.values[19] = tokenCoding7128_19; +} +x64Token x64Parser::tokenBranches7127[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7128, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7126[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7125[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7124[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5833_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7279_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5833_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5833(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5833_16; - operand.values[17] = tokenCoding5833_17; - operand.values[23] = tokenCoding5833_23; - operand.values[18] = tokenCoding5833_18; - operand.values[19] = tokenCoding5833_19; -} -x64Token x64Parser::tokenBranches5832[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5833, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5831[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5832}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5836_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7279_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7279_18; + operand.values[19] = tokenCoding7279_19; +} +x64Token x64Parser::tokenBranches7278[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7279, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5836_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_16[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_17[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 39, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_18[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5836_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5836(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5836_16; - operand.values[17] = tokenCoding5836_17; - operand.values[23] = tokenCoding5836_23; - operand.values[18] = tokenCoding5836_18; - operand.values[19] = tokenCoding5836_19; -} -x64Token x64Parser::tokenBranches5835[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5836, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5834[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5835}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5839_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7131_19[] = { + { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) +{ + operand.values[30] = new Coding[2]; + CleanupValues.push_back(operand.values[30]); + operand.values[30]->type = Coding::reg; + operand.values[30]->val = inputTokens[tokenPos]->val->ival; + operand.values[30]->bits = 0; + operand.values[30]->field = 0; + operand.values[30]->unary = 0; + operand.values[30]->binary = 0; + operand.values[30][1].type = Coding::eot; + operand.values[16] = tokenCoding7131_16; + operand.values[17] = tokenCoding7131_17; + operand.values[18] = tokenCoding7131_18; + operand.values[19] = tokenCoding7131_19; +} +Coding x64Parser::tokenCoding7134_16[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_17[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_23[] = { - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_18[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7134_19[] = { + { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) +{ + operand.values[31] = new Coding[2]; + CleanupValues.push_back(operand.values[31]); + operand.values[31]->type = Coding::reg; + operand.values[31]->val = inputTokens[tokenPos]->val->ival; + operand.values[31]->bits = 0; + operand.values[31]->field = 0; + operand.values[31]->unary = 0; + operand.values[31]->binary = 0; + operand.values[31][1].type = Coding::eot; + operand.values[16] = tokenCoding7134_16; + operand.values[17] = tokenCoding7134_17; + operand.values[18] = tokenCoding7134_18; + operand.values[19] = tokenCoding7134_19; +} +Coding x64Parser::tokenCoding7137_16[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5839_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5839(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5839_16; - operand.values[17] = tokenCoding5839_17; - operand.values[23] = tokenCoding5839_23; - operand.values[18] = tokenCoding5839_18; - operand.values[19] = tokenCoding5839_19; -} -x64Token x64Parser::tokenBranches5838[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc5839, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5837[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5838}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5842_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_17[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_18[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7137_19[] = { + { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) +{ + operand.values[32] = new Coding[2]; + CleanupValues.push_back(operand.values[32]); + operand.values[32]->type = Coding::reg; + operand.values[32]->val = inputTokens[tokenPos]->val->ival; + operand.values[32]->bits = 0; + operand.values[32]->field = 0; + operand.values[32]->unary = 0; + operand.values[32]->binary = 0; + operand.values[32][1].type = Coding::eot; + operand.values[16] = tokenCoding7137_16; + operand.values[17] = tokenCoding7137_17; + operand.values[18] = tokenCoding7137_18; + operand.values[19] = tokenCoding7137_19; +} +Coding x64Parser::tokenCoding7264_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7264_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5842_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 37, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5842(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5842_16; - operand.values[17] = tokenCoding5842_17; - operand.values[23] = tokenCoding5842_23; - operand.values[18] = tokenCoding5842_18; - operand.values[19] = tokenCoding5842_19; -} -x64Token x64Parser::tokenBranches5841[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc5842, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5840[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5841}, {x64Token::EOT}}; -void x64Parser::TokenFunc5837(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc5840(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7264_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7264_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7264_16; + operand.values[17] = tokenCoding7264_17; + operand.values[18] = tokenCoding7264_18; + operand.values[19] = tokenCoding7264_19; +} +x64Token x64Parser::tokenBranches7130[] = { + {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7131, }, + {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7134, }, + {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7137, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7129[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 594; +} +x64Token x64Parser::tokenBranches7142[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7143, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7141[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7140[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7151(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 595; +} +x64Token x64Parser::tokenBranches7150[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7151, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7149[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7148[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7165(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 597; +} +x64Token x64Parser::tokenBranches7164[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7165, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7163[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7162[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches5830[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches5831}, - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches5834}, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5837, x64Parser::tokenBranches5837}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5840, x64Parser::tokenBranches5840}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5848_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7147[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7148, x64Parser::tokenBranches7148 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7162, x64Parser::tokenBranches7162 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7146[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 596; +} +x64Token x64Parser::tokenBranches7156[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7155[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7154[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7139[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7140, x64Parser::tokenBranches7140 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5848_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5848_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5848(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5848_16; - operand.values[17] = tokenCoding5848_17; - operand.values[18] = tokenCoding5848_18; -} -x64Token x64Parser::tokenBranches5847[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5848, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5846[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5847}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5845[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5846}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5844[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5845}, {x64Token::EOT}}; -void x64Parser::TokenFunc5844(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5843[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc5844, x64Parser::tokenBranches5844}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5854_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5854_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7225_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5854_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5854(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding5854_16; - operand.values[17] = tokenCoding5854_17; - operand.values[18] = tokenCoding5854_18; -} -x64Token x64Parser::tokenBranches5853[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc5854, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5852[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5853}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5851[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5852}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5850[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5851}, {x64Token::EOT}}; -void x64Parser::TokenFunc5850(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +Coding x64Parser::tokenCoding7225_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7225_16; + operand.values[17] = tokenCoding7225_17; + operand.values[18] = tokenCoding7225_18; + operand.values[19] = tokenCoding7225_19; } -x64Token x64Parser::tokenBranches5849[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc5850, x64Parser::tokenBranches5850}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5865_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding5865_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5865_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5865_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5865(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5865_16; - operand.values[17] = tokenCoding5865_17; - operand.values[18] = tokenCoding5865_18; - operand.values[19] = tokenCoding5865_19; -} -x64Token x64Parser::tokenBranches5864[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc5865, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5863[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5864}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5862[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches5863}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5870_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5870_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7229_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5870_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5870(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 469; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5870_16; - operand.values[17] = tokenCoding5870_17; - operand.values[18] = tokenCoding5870_18; +Coding x64Parser::tokenCoding7229_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7229_16; + operand.values[17] = tokenCoding7229_17; + operand.values[23] = tokenCoding7229_23; + operand.values[18] = tokenCoding7229_18; + operand.values[19] = tokenCoding7229_19; +} +x64Token x64Parser::tokenBranches7224[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7225, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7229, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7223[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7138[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 598; +} +x64Token x64Parser::tokenBranches7170[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7171, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7169[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7168[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7179(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 599; +} +x64Token x64Parser::tokenBranches7178[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7179, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7177[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7176[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7193(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 601; +} +x64Token x64Parser::tokenBranches7192[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7193, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7191[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7190[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding5871_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7175[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7176, x64Parser::tokenBranches7176 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7190, x64Parser::tokenBranches7190 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7174[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 600; +} +x64Token x64Parser::tokenBranches7184[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7183[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7182[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7167[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5871_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5871_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5871(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 470; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding5871_16; - operand.values[17] = tokenCoding5871_17; - operand.values[18] = tokenCoding5871_18; -} -x64Token x64Parser::tokenBranches5869[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5870, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc5871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5880(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 471; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5879[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc5880, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5884(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 472; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches5883[] = {{ - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5884, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5878[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches5879}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches5883}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5877[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5878}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding5892_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7233_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7233_16; + operand.values[17] = tokenCoding7233_17; + operand.values[18] = tokenCoding7233_18; + operand.values[19] = tokenCoding7233_19; +} +Coding x64Parser::tokenCoding7258_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5892_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5892(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5892_16; - operand.values[17] = tokenCoding5892_17; - operand.values[18] = tokenCoding5892_18; - operand.values[19] = tokenCoding5892_19; -} -x64Token x64Parser::tokenBranches5891[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5892, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5894_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5894_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5894_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7258_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7258_16; + operand.values[17] = tokenCoding7258_17; + operand.values[18] = tokenCoding7258_18; + operand.values[19] = tokenCoding7258_19; +} +x64Token x64Parser::tokenBranches7232[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7233, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7258, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7231[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7166[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 602; +} +x64Token x64Parser::tokenBranches7198[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7199, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7207(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 603; +} +x64Token x64Parser::tokenBranches7206[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7207, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7205[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7204[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7221(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 605; +} +x64Token x64Parser::tokenBranches7220[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7221, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7219[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7218[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7204(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7218(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7203[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7204, x64Parser::tokenBranches7204 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7218, x64Parser::tokenBranches7218 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7202[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7213(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 604; +} +x64Token x64Parser::tokenBranches7212[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7213, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7211[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7212 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7210[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7195[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5894_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5894(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5894_16; - operand.values[17] = tokenCoding5894_17; - operand.values[18] = tokenCoding5894_18; - operand.values[19] = tokenCoding5894_19; -} -x64Token x64Parser::tokenBranches5893[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5894, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5896_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5896_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5896(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5896_16; - operand.values[17] = tokenCoding5896_17; - operand.values[18] = tokenCoding5896_18; - operand.values[19] = tokenCoding5896_19; -} -x64Token x64Parser::tokenBranches5895[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5896, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5905_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7237_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7237_16; + operand.values[17] = tokenCoding7237_17; + operand.values[18] = tokenCoding7237_18; + operand.values[19] = tokenCoding7237_19; +} +x64Token x64Parser::tokenBranches7236[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7237, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7235[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7194[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5905_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5905_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5905_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5905(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5905_16; - operand.values[17] = tokenCoding5905_17; - operand.values[18] = tokenCoding5905_18; - operand.values[19] = tokenCoding5905_19; -} -x64Token x64Parser::tokenBranches5904[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5905, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding5908_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5908_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7241_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7241_16; + operand.values[17] = tokenCoding7241_17; + operand.values[18] = tokenCoding7241_18; + operand.values[19] = tokenCoding7241_19; +} +x64Token x64Parser::tokenBranches7240[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7241, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7239[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7238[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5908_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5908_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5908(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5908_16; - operand.values[17] = tokenCoding5908_17; - operand.values[18] = tokenCoding5908_18; - operand.values[19] = tokenCoding5908_19; -} -x64Token x64Parser::tokenBranches5907[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5908, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5898(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 475; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5900(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 476; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding5902_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7245_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5902_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc5902(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5902_16; - operand.values[17] = tokenCoding5902_17; - operand.values[18] = tokenCoding5902_18; - operand.values[19] = tokenCoding5902_19; -} -x64Token x64Parser::tokenBranches5897[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc5898, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc5900, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5902, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5904}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5907}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5877(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::number; - operand.values[2]->val = operands.size(); - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5885(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 473; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc5886(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 474; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7245(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7245_16; + operand.values[17] = tokenCoding7245_17; + operand.values[18] = tokenCoding7245_18; + operand.values[19] = tokenCoding7245_19; } -Coding x64Parser::tokenCoding5887_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7244[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7245, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5887_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5887_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5887_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7248_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7248_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5887(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5887_16; - operand.values[17] = tokenCoding5887_17; - operand.values[18] = tokenCoding5887_18; - operand.values[19] = tokenCoding5887_19; + operand.values[16] = tokenCoding7248_16; + operand.values[17] = tokenCoding7248_17; + operand.values[18] = tokenCoding7248_18; + operand.values[19] = tokenCoding7248_19; } -Coding x64Parser::tokenCoding5888_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5888_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7251_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5888(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5888_16; - operand.values[17] = tokenCoding5888_17; - operand.values[18] = tokenCoding5888_18; - operand.values[19] = tokenCoding5888_19; + operand.values[16] = tokenCoding7251_16; + operand.values[17] = tokenCoding7251_17; + operand.values[18] = tokenCoding7251_18; + operand.values[19] = tokenCoding7251_19; } -Coding x64Parser::tokenCoding5889_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5889_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7254_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc5889(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding5889_16; - operand.values[17] = tokenCoding5889_17; - operand.values[18] = tokenCoding5889_18; - operand.values[19] = tokenCoding5889_19; + operand.values[16] = tokenCoding7254_16; + operand.values[17] = tokenCoding7254_17; + operand.values[18] = tokenCoding7254_18; + operand.values[19] = tokenCoding7254_19; } -Coding x64Parser::tokenCoding5890_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7243[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7248, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7251, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7254, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5890_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7242[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding5890_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7275_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding5890_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7275_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7275_18; + operand.values[19] = tokenCoding7275_19; +} +x64Token x64Parser::tokenBranches7274[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7275, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc5890(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding5890_16; - operand.values[17] = tokenCoding5890_17; - operand.values[18] = tokenCoding5890_18; - operand.values[19] = tokenCoding5890_19; -} -x64Token x64Parser::tokenBranches5876[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc5877, x64Parser::tokenBranches5877}, - { - x64Token::NUMBER, - 13, - 1, - 0, - NULL, - &x64Parser::TokenFunc5885, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc5886, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc5887, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc5888, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc5889, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc5890, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches5891}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches5893}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches5895}, - {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches5897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc5912(x64Operand& operand, int tokenPos) { operand.operandCoding = 477; } -x64Token x64Parser::tokenBranches5911[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc5912, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc5962(x64Operand& operand, int tokenPos) { operand.operandCoding = 478; } -x64Token x64Parser::tokenBranches5961[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5962, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5960[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5961}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5959[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5960}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5958[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5959}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5957[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5958}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5956[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5957}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5955[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5956}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5954[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5955}, {x64Token::EOT}}; -void x64Parser::TokenFunc5988(x64Operand& operand, int tokenPos) { operand.operandCoding = 480; } -x64Token x64Parser::tokenBranches5987[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5988, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5986[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches5987}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5985[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5986}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5984[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5985}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5983[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5984}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5982[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5983}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5981[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5982}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5980[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5981}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5953[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5954}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5980}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5952[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5953}, {x64Token::EOT}}; -void x64Parser::TokenFunc5975(x64Operand& operand, int tokenPos) { operand.operandCoding = 479; } -x64Token x64Parser::tokenBranches5974[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc5975, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5973[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches5974}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5972[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5973}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5971[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5972}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5970[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5971}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5969[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5970}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5968[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5969}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5967[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5968}, {x64Token::EOT}}; -void x64Parser::TokenFunc6001(x64Operand& operand, int tokenPos) { operand.operandCoding = 481; } -x64Token x64Parser::tokenBranches6000[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6001, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5999[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6000}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5998[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5999}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5997[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5998}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5996[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches5997}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5995[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5996}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5994[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches5995}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5993[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches5994}, {x64Token::EOT}}; -void x64Parser::TokenFunc6023(x64Operand& operand, int tokenPos) { operand.operandCoding = 483; } -x64Token x64Parser::tokenBranches6022[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6023, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6021[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6022}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6020[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6021}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6019[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6020}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6018[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6019}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6017[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6018}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6016[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6017}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6015[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6016}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5966[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches5967}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches5993}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6015}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5965[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches5966}, {x64Token::EOT}}; -void x64Parser::TokenFunc6010(x64Operand& operand, int tokenPos) { operand.operandCoding = 482; } -x64Token x64Parser::tokenBranches6009[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6010, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6008[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6009}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6007[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6008}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6006[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6007}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6005[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6006}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6004[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6005}, {x64Token::EOT}}; -void x64Parser::TokenFunc5965(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches5951[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches5952}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc5965, x64Parser::tokenBranches5965}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6004}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5950[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches5951}, {x64Token::EOT}}; -void x64Parser::TokenFunc6036(x64Operand& operand, int tokenPos) { operand.operandCoding = 484; } -x64Token x64Parser::tokenBranches6035[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6036, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6034[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6035}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6033[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6034}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6032[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6033}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6031[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6032}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6030[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6031}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6029[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6030}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6028[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6029}, {x64Token::EOT}}; -void x64Parser::TokenFunc6062(x64Operand& operand, int tokenPos) { operand.operandCoding = 486; } -x64Token x64Parser::tokenBranches6061[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6062, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6060[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6061}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6059[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6060}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6058[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6059}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6057[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6058}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6056[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6057}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6055[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6056}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6054[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6055}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6027[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6028}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6054}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6026[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6027}, {x64Token::EOT}}; -void x64Parser::TokenFunc6049(x64Operand& operand, int tokenPos) { operand.operandCoding = 485; } -x64Token x64Parser::tokenBranches6048[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6049, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6047[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6048}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6046[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6047}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6045[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6046}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6044[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6045}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6043[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6044}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6042[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6043}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6041[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6042}, {x64Token::EOT}}; -void x64Parser::TokenFunc6075(x64Operand& operand, int tokenPos) { operand.operandCoding = 487; } -x64Token x64Parser::tokenBranches6074[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6075, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6073[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6074}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6072[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6073}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6071[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6072}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6070[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6071}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6069[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6070}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6068[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6069}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6067[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6068}, {x64Token::EOT}}; -void x64Parser::TokenFunc6095(x64Operand& operand, int tokenPos) { operand.operandCoding = 489; } -x64Token x64Parser::tokenBranches6094[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6095, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6093[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6094}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6092[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6093}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6091[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6092}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6090[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6091}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6089[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6090}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6040[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6041}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6067}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6089}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6039[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6040}, {x64Token::EOT}}; -void x64Parser::TokenFunc6084(x64Operand& operand, int tokenPos) { operand.operandCoding = 488; } -x64Token x64Parser::tokenBranches6083[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6084, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6082[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6083}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6081[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6082}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6080[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6081}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6079[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6080}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6078[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6079}, {x64Token::EOT}}; -void x64Parser::TokenFunc6039(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6025[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6026}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6039, x64Parser::tokenBranches6039}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6078}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6024[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6025}, {x64Token::EOT}}; -void x64Parser::TokenFunc6108(x64Operand& operand, int tokenPos) { operand.operandCoding = 490; } -x64Token x64Parser::tokenBranches6107[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6108, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6106[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6107}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6105[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6106}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6104[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6105}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6103[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6104}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6102[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6103}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6101[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6102}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6100[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6101}, {x64Token::EOT}}; -void x64Parser::TokenFunc6134(x64Operand& operand, int tokenPos) { operand.operandCoding = 492; } -x64Token x64Parser::tokenBranches6133[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6134, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6132[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6133}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6131[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6132}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6130[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6131}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6129[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6130}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6128[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6129}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6127[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6128}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6126[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6127}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6099[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6100}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6126}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6098[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6099}, {x64Token::EOT}}; -void x64Parser::TokenFunc6121(x64Operand& operand, int tokenPos) { operand.operandCoding = 491; } -x64Token x64Parser::tokenBranches6120[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6121, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6119[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6120}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6118[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6119}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6117[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6118}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6116[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6117}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6115[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6116}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6114[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6115}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6113[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6114}, {x64Token::EOT}}; -void x64Parser::TokenFunc6147(x64Operand& operand, int tokenPos) { operand.operandCoding = 493; } -x64Token x64Parser::tokenBranches6146[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6147, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6145[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6146}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6144[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6145}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6143[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6144}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6142[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6143}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6141[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6142}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6140[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6141}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6139[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6140}, {x64Token::EOT}}; -void x64Parser::TokenFunc6167(x64Operand& operand, int tokenPos) { operand.operandCoding = 495; } -x64Token x64Parser::tokenBranches6166[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6167, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6165[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6166}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6164[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6165}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6163[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6164}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6162[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6163}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6161[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6162}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6112[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6113}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6139}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6161}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6111[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6112}, {x64Token::EOT}}; -void x64Parser::TokenFunc6156(x64Operand& operand, int tokenPos) { operand.operandCoding = 494; } -x64Token x64Parser::tokenBranches6155[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6156, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6154[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6155}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6153[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6154}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6152[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6153}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6151[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6152}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6150[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6151}, {x64Token::EOT}}; -void x64Parser::TokenFunc6111(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6097[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6098}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6111, x64Parser::tokenBranches6111}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6150}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6096[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6097}, {x64Token::EOT}}; -void x64Parser::TokenFunc6180(x64Operand& operand, int tokenPos) { operand.operandCoding = 496; } -x64Token x64Parser::tokenBranches6179[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6180, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6178[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6179}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6177[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6176[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6177}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6175[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6176}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6174[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6175}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6173[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6174}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6172[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6173}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6171[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6172}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6170[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6171}, {x64Token::EOT}}; -void x64Parser::TokenFunc6193(x64Operand& operand, int tokenPos) { operand.operandCoding = 497; } -x64Token x64Parser::tokenBranches6192[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6193, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6191[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6192}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6190[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6191}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6189[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6190}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6188[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6189}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6187[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6188}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6186[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6187}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6185[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6186}, {x64Token::EOT}}; -void x64Parser::TokenFunc6213(x64Operand& operand, int tokenPos) { operand.operandCoding = 499; } -x64Token x64Parser::tokenBranches6212[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6213, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6211[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6212}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6210[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6211}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6209[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6210}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6208[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6209}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6207[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6208}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6184[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6185}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6207}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6183[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6184}, {x64Token::EOT}}; -void x64Parser::TokenFunc6202(x64Operand& operand, int tokenPos) { operand.operandCoding = 498; } -x64Token x64Parser::tokenBranches6201[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6202, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6200[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6201}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6199[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6200}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6198[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6199}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6196[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6197}, {x64Token::EOT}}; -void x64Parser::TokenFunc6183(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6169[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6170}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6183, x64Parser::tokenBranches6183}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6196}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6168[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6169}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches5949[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches5950}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6024}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6096}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6168}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6218(x64Operand& operand, int tokenPos) { operand.operandCoding = 500; } -x64Token x64Parser::tokenBranches6217[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6218, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6223_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6223_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6223(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6223_16; - operand.values[17] = tokenCoding6223_17; - operand.values[18] = tokenCoding6223_18; - operand.values[19] = tokenCoding6223_19; -} -Coding x64Parser::tokenCoding6227_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7261_19[] = { + { CODING_NAME("segm") Coding::stateFunc, 4 }, + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7261_16; + operand.values[17] = tokenCoding7261_17; + operand.values[18] = tokenCoding7261_18; + operand.values[19] = tokenCoding7261_19; +} +x64Token x64Parser::tokenBranches7260[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7261, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7259[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6227_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7283_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6227_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7283_19[] = { + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7283_18; + operand.values[19] = tokenCoding7283_19; +} +x64Token x64Parser::tokenBranches7282[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7283, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6227_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_16[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6227_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6227(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6227_16; - operand.values[17] = tokenCoding6227_17; - operand.values[23] = tokenCoding6227_23; - operand.values[18] = tokenCoding6227_18; - operand.values[19] = tokenCoding6227_19; -} -x64Token x64Parser::tokenBranches6222[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6223, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc6227, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6221[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6222}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6220[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6221}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6231_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_17[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6231_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_18[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6231_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7267_19[] = { + { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; + operand.values[16] = tokenCoding7267_16; + operand.values[17] = tokenCoding7267_17; + operand.values[18] = tokenCoding7267_18; + operand.values[19] = tokenCoding7267_19; +} +x64Token x64Parser::tokenBranches7266[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7265[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6231_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6231(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6231_16; - operand.values[17] = tokenCoding6231_17; - operand.values[18] = tokenCoding6231_18; - operand.values[19] = tokenCoding6231_19; -} -x64Token x64Parser::tokenBranches6230[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6231, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6229[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6230}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6228[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6229}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6235_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7271_18[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6235_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7271_19[] = { + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[18] = tokenCoding7271_18; + operand.values[19] = tokenCoding7271_19; +} +x64Token x64Parser::tokenBranches7270[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7271, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7269[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7268[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) +{ + operand.values[30] = new Coding[2]; + CleanupValues.push_back(operand.values[30]); + operand.values[30]->type = Coding::reg; + operand.values[30]->val = inputTokens[tokenPos]->val->ival; + operand.values[30]->bits = 0; + operand.values[30]->field = 0; + operand.values[30]->unary = 0; + operand.values[30]->binary = 0; + operand.values[30][1].type = Coding::eot; +} +void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) +{ + operand.values[31] = new Coding[2]; + CleanupValues.push_back(operand.values[31]); + operand.values[31]->type = Coding::reg; + operand.values[31]->val = inputTokens[tokenPos]->val->ival; + operand.values[31]->bits = 0; + operand.values[31]->field = 0; + operand.values[31]->unary = 0; + operand.values[31]->binary = 0; + operand.values[31][1].type = Coding::eot; +} +void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) +{ + operand.values[32] = new Coding[2]; + CleanupValues.push_back(operand.values[32]); + operand.values[32]->type = Coding::reg; + operand.values[32]->val = inputTokens[tokenPos]->val->ival; + operand.values[32]->bits = 0; + operand.values[32]->field = 0; + operand.values[32]->unary = 0; + operand.values[32]->binary = 0; + operand.values[32][1].type = Coding::eot; +} +void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) +{ + operand.values[33] = new Coding[2]; + CleanupValues.push_back(operand.values[33]); + operand.values[33]->type = Coding::reg; + operand.values[33]->val = inputTokens[tokenPos]->val->ival; + operand.values[33]->bits = 0; + operand.values[33]->field = 0; + operand.values[33]->unary = 0; + operand.values[33]->binary = 0; + operand.values[33][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6975[] = { + {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6976, x64Parser::tokenBranches6976 }, + {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6979, x64Parser::tokenBranches6979 }, + {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7069, x64Parser::tokenBranches7069 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7077, x64Parser::tokenBranches7077 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7081, x64Parser::tokenBranches7081 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7085, x64Parser::tokenBranches7085 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7242, x64Parser::tokenBranches7242 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7297(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 606; +} +x64Token x64Parser::tokenBranches7296[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7297, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7295[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7294[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7310(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 607; +} +x64Token x64Parser::tokenBranches7309[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7310, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7308[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7307[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7293[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7307, x64Parser::tokenBranches7307 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6235_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7292[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6235_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6235(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6235_16; - operand.values[17] = tokenCoding6235_17; - operand.values[18] = tokenCoding6235_18; - operand.values[19] = tokenCoding6235_19; -} -x64Token x64Parser::tokenBranches6234[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6235, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6233[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6234}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6232[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches6233}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6239_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7291[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7290[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7289[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6239_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6239(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding6239_16; - operand.values[17] = tokenCoding6239_17; - operand.values[18] = tokenCoding6239_18; - operand.values[19] = tokenCoding6239_19; -} -x64Token x64Parser::tokenBranches6238[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6239, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6237[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6238}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6236[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6237}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6219[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6220}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6228}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6232}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6236}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6241_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7323(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 608; +} +x64Token x64Parser::tokenBranches7322[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7323, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7321[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7320[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6241_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6241(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6241_16; - operand.values[17] = tokenCoding6241_17; - operand.values[18] = tokenCoding6241_18; - operand.values[19] = tokenCoding6241_19; -} -x64Token x64Parser::tokenBranches6240[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6241, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6243_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7336(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 609; +} +x64Token x64Parser::tokenBranches7335[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7336, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7334[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7333[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6243_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6243(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6243_16; - operand.values[17] = tokenCoding6243_17; - operand.values[18] = tokenCoding6243_18; - operand.values[19] = tokenCoding6243_19; -} -x64Token x64Parser::tokenBranches6242[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6243, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6246(x64Operand& operand, int tokenPos) { operand.operandCoding = 501; } -x64Token x64Parser::tokenBranches6245[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6246, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6258(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 502; - operand.values[27] = new Coding[2]; - CleanupValues.push_back(operand.values[27]); - operand.values[27]->type = Coding::number; - operand.values[27]->val = operands.size(); - operand.values[27]->bits = 0; - operand.values[27]->field = 0; - operand.values[27]->unary = 0; - operand.values[27]->binary = 0; - operand.values[27][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6257[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6258, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6256[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6255[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256}, {x64Token::EOT}}; -void x64Parser::TokenFunc6255(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6254[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc6255, x64Parser::tokenBranches6255}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6253[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6262_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7319[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7333, x64Parser::tokenBranches7333 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7318[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&'}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7317[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>'}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6262(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6262_16; - operand.values[17] = tokenCoding6262_17; - operand.values[18] = tokenCoding6262_18; - operand.values[19] = tokenCoding6262_19; -} -x64Token x64Parser::tokenBranches6261[] = {{ - x64Token::ADDRESSCLASS, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6262, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6260[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261}, {x64Token::EOT}}; -void x64Parser::TokenFunc6260(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7316[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7315[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7288[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7287[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7286[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7345(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches6259[] = { - {x64Token::NUMBER, 2, 0, 0, NULL, &x64Parser::TokenFunc6260, x64Parser::tokenBranches6260}, {x64Token::EOT}}; -void x64Parser::TokenFunc6275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6274[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6275, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6273[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6272[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6279(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6278[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6279, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6277[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6276[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6283(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6282[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6283, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6281[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6280[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6287(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6286[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6287, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6285[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6284[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6291(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6290[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6291, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6289[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6288[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6295(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6294[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6295, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6293[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6292[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6299(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6298[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6299, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6297[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6296[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6303(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6302[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6303, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6301[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6300[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6307(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6306[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6307, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6305[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6310_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7344[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7345, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7356(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 611; +} +x64Token x64Parser::tokenBranches7355[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7356, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6310(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6310_16; - operand.values[17] = tokenCoding6310_17; - operand.values[19] = tokenCoding6310_19; -} -x64Token x64Parser::tokenBranches6309[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6310, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6312_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7354[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7353[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6312(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6312_16; - operand.values[17] = tokenCoding6312_17; - operand.values[19] = tokenCoding6312_19; -} -x64Token x64Parser::tokenBranches6311[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6312, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6308(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6304[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305}, - { - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6308, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6316(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6315[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6316, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6313[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6320(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6319[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6320, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6318[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6317[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6324_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7343[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7353, x64Parser::tokenBranches7353 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7342[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6324(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6324_16; - operand.values[17] = tokenCoding6324_17; - operand.values[19] = tokenCoding6324_19; -} -x64Token x64Parser::tokenBranches6323[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6324, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6326_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7341[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7340[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6326(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6326_16; - operand.values[17] = tokenCoding6326_17; - operand.values[19] = tokenCoding6326_19; -} -x64Token x64Parser::tokenBranches6325[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6326, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6322(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6321[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6322, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6337_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7339[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6337_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6337(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6337_18; - operand.values[19] = tokenCoding6337_19; -} -x64Token x64Parser::tokenBranches6336[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6337, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6339_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7338[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6339_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6339(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6339_18; - operand.values[19] = tokenCoding6339_19; -} -x64Token x64Parser::tokenBranches6338[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6339, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6347_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7285[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7369(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 612; +} +x64Token x64Parser::tokenBranches7368[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7369, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7367[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6347(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6347_16; - operand.values[17] = tokenCoding6347_17; - operand.values[18] = tokenCoding6347_18; - operand.values[19] = tokenCoding6347_19; -} -x64Token x64Parser::tokenBranches6346[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6347, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6349_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7366[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7382(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 613; +} +x64Token x64Parser::tokenBranches7381[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7382, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7380[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6349(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6349_16; - operand.values[17] = tokenCoding6349_17; - operand.values[18] = tokenCoding6349_18; - operand.values[19] = tokenCoding6349_19; -} -x64Token x64Parser::tokenBranches6348[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6349, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6351_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7379[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7365[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7379, x64Parser::tokenBranches7379 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7364[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6351(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6351_16; - operand.values[17] = tokenCoding6351_17; - operand.values[18] = tokenCoding6351_18; - operand.values[19] = tokenCoding6351_19; -} -x64Token x64Parser::tokenBranches6350[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6351, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6345[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6359_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7363[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7362[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7361[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6359(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6359_16; - operand.values[17] = tokenCoding6359_17; - operand.values[18] = tokenCoding6359_18; - operand.values[19] = tokenCoding6359_19; -} -x64Token x64Parser::tokenBranches6358[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6359, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6361_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7395(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 614; +} +x64Token x64Parser::tokenBranches7394[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7395, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7393[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7392[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6361(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6361_16; - operand.values[17] = tokenCoding6361_17; - operand.values[18] = tokenCoding6361_18; - operand.values[19] = tokenCoding6361_19; -} -x64Token x64Parser::tokenBranches6360[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6361, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6357[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6367_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7408(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 615; +} +x64Token x64Parser::tokenBranches7407[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7408, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7406[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7405[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6367(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6367_16; - operand.values[17] = tokenCoding6367_17; - operand.values[18] = tokenCoding6367_18; - operand.values[19] = tokenCoding6367_19; -} -x64Token x64Parser::tokenBranches6366[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6367, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6369_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7391[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7405, x64Parser::tokenBranches7405 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7390[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7389[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6369(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6369_16; - operand.values[17] = tokenCoding6369_17; - operand.values[18] = tokenCoding6369_18; - operand.values[19] = tokenCoding6369_19; -} -x64Token x64Parser::tokenBranches6368[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6369, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6371_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7388[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7387[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7360[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6371(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6371_16; - operand.values[17] = tokenCoding6371_17; - operand.values[18] = tokenCoding6371_18; - operand.values[19] = tokenCoding6371_19; -} -x64Token x64Parser::tokenBranches6370[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6371, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6365_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7359[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6365_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6365(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6365_18; - operand.values[19] = tokenCoding6365_19; -} -x64Token x64Parser::tokenBranches6364[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6365, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368}, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6375_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7358[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7417(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 616; +} +x64Token x64Parser::tokenBranches7416[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7417, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7428(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 617; +} +x64Token x64Parser::tokenBranches7427[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7428, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6375(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6375_16; - operand.values[17] = tokenCoding6375_17; - operand.values[18] = tokenCoding6375_18; - operand.values[19] = tokenCoding6375_19; -} -x64Token x64Parser::tokenBranches6374[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6375, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6373[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6377_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7426[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7425[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7415[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7425, x64Parser::tokenBranches7425 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6377(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6377_16; - operand.values[17] = tokenCoding6377_17; - operand.values[18] = tokenCoding6377_18; - operand.values[19] = tokenCoding6377_19; -} -x64Token x64Parser::tokenBranches6376[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6377, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6388_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7414[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7413[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7412[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6388(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6388_16; - operand.values[17] = tokenCoding6388_17; - operand.values[18] = tokenCoding6388_18; - operand.values[19] = tokenCoding6388_19; -} -x64Token x64Parser::tokenBranches6387[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6388, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6395_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7411[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7410[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7357[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6395(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6395_16; - operand.values[17] = tokenCoding6395_17; - operand.values[18] = tokenCoding6395_18; - operand.values[19] = tokenCoding6395_19; -} -x64Token x64Parser::tokenBranches6394[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6395, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6397_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7441(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 618; +} +x64Token x64Parser::tokenBranches7440[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7441, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7439[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7438[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6397(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6397_16; - operand.values[17] = tokenCoding6397_17; - operand.values[18] = tokenCoding6397_18; - operand.values[19] = tokenCoding6397_19; -} -x64Token x64Parser::tokenBranches6396[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6397, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6406_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7454(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 619; +} +x64Token x64Parser::tokenBranches7453[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7454, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7452[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7451[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6406(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6406_16; - operand.values[17] = tokenCoding6406_17; - operand.values[18] = tokenCoding6406_18; - operand.values[19] = tokenCoding6406_19; -} -x64Token x64Parser::tokenBranches6405[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6406, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6408_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7437[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7451, x64Parser::tokenBranches7451 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7436[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7435[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6408(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6408_16; - operand.values[17] = tokenCoding6408_17; - operand.values[18] = tokenCoding6408_18; - operand.values[19] = tokenCoding6408_19; -} -x64Token x64Parser::tokenBranches6407[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6408, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6404_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7434[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6404_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6404(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6404_18; - operand.values[19] = tokenCoding6404_19; -} -x64Token x64Parser::tokenBranches6403[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6404, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6411_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7433[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7467(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 620; +} +x64Token x64Parser::tokenBranches7466[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7467, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7465[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6411(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6411_16; - operand.values[17] = tokenCoding6411_17; - operand.values[18] = tokenCoding6411_18; - operand.values[19] = tokenCoding6411_19; -} -x64Token x64Parser::tokenBranches6410[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6411, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6409[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6414_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7464[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7480(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 621; +} +x64Token x64Parser::tokenBranches7479[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7480, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7478[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6414(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6414_16; - operand.values[17] = tokenCoding6414_17; - operand.values[18] = tokenCoding6414_18; - operand.values[19] = tokenCoding6414_19; -} -x64Token x64Parser::tokenBranches6413[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6414, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6412[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6416_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7477[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7463[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7477, x64Parser::tokenBranches7477 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7462[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6416_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6416(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6416_16; - operand.values[17] = tokenCoding6416_17; - operand.values[18] = tokenCoding6416_18; - operand.values[19] = tokenCoding6416_19; -} -x64Token x64Parser::tokenBranches6415[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6416, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6418_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7461[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7460[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7459[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6418(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6418_16; - operand.values[17] = tokenCoding6418_17; - operand.values[18] = tokenCoding6418_18; - operand.values[19] = tokenCoding6418_19; -} -x64Token x64Parser::tokenBranches6417[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6418, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6422_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7432[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7431[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7430[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6422_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6422(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6422_16; - operand.values[17] = tokenCoding6422_17; - operand.values[18] = tokenCoding6422_18; - operand.values[19] = tokenCoding6422_19; -} -x64Token x64Parser::tokenBranches6421[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6422, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6424_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7489(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 622; +} +x64Token x64Parser::tokenBranches7488[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7489, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7500(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 623; +} +x64Token x64Parser::tokenBranches7499[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7500, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7498[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6424_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6424(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6424_16; - operand.values[17] = tokenCoding6424_17; - operand.values[18] = tokenCoding6424_18; - operand.values[19] = tokenCoding6424_19; -} -x64Token x64Parser::tokenBranches6423[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6424, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6426_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7497[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7487[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7497, x64Parser::tokenBranches7497 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7486[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6426(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6426_16; - operand.values[17] = tokenCoding6426_17; - operand.values[18] = tokenCoding6426_18; - operand.values[19] = tokenCoding6426_19; -} -x64Token x64Parser::tokenBranches6425[] = {{ - x64Token::ADDRESSCLASS, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6426, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6420_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7485[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6420_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6420(x64Operand& operand, int tokenPos) -{ - operand.values[18] = tokenCoding6420_18; - operand.values[19] = tokenCoding6420_19; -} -x64Token x64Parser::tokenBranches6419[] = {{ - x64Token::ADDRESSCLASS, - 12, - 1, - 0, - NULL, - &x64Parser::TokenFunc6420, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423}, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6429_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7484[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7483[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7482[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6429(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6429_16; - operand.values[17] = tokenCoding6429_17; - operand.values[18] = tokenCoding6429_18; - operand.values[19] = tokenCoding6429_19; -} -x64Token x64Parser::tokenBranches6428[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6429, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6430(x64Operand& operand, int tokenPos) { operand.operandCoding = 503; } -x64Token x64Parser::tokenBranches6427[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428}, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6430, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6433_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7429[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7513(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 624; +} +x64Token x64Parser::tokenBranches7512[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7513, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7511[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6433(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6433_16; - operand.values[17] = tokenCoding6433_17; - operand.values[18] = tokenCoding6433_18; - operand.values[19] = tokenCoding6433_19; -} -x64Token x64Parser::tokenBranches6432[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6433, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6434(x64Operand& operand, int tokenPos) { operand.operandCoding = 504; } -x64Token x64Parser::tokenBranches6431[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432}, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6434, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6444(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6443[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6444, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6442[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6441[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6448(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6447[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6448, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6446[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6445[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6457(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6456[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6457, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6455[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6454[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6461(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 462; - operand.values[15] = new Coding[2]; - CleanupValues.push_back(operand.values[15]); - operand.values[15]->type = Coding::reg; - operand.values[15]->val = inputTokens[tokenPos]->val->ival; - operand.values[15]->bits = 0; - operand.values[15]->field = 0; - operand.values[15]->unary = 0; - operand.values[15]->binary = 0; - operand.values[15][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6460[] = {{ - x64Token::REGISTERCLASS, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6461, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6459[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6458[] = {{x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6463_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7510[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7526(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 625; +} +x64Token x64Parser::tokenBranches7525[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7526, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7524[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6463(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6463_16; - operand.values[17] = tokenCoding6463_17; - operand.values[18] = tokenCoding6463_18; - operand.values[19] = tokenCoding6463_19; -} -x64Token x64Parser::tokenBranches6462[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6463, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6465_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7523[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7509[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7523, x64Parser::tokenBranches7523 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7508[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6465(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6465_16; - operand.values[17] = tokenCoding6465_17; - operand.values[18] = tokenCoding6465_18; - operand.values[19] = tokenCoding6465_19; -} -x64Token x64Parser::tokenBranches6464[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6465, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6476(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 505; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6475[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6476, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6503_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7507[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7506[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7505[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 4}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6503(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6503_16; - operand.values[17] = tokenCoding6503_17; - operand.values[18] = tokenCoding6503_18; - operand.values[19] = tokenCoding6503_19; -} -x64Token x64Parser::tokenBranches6502[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6503, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6509_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7504[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7503[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7502[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6509(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6509_16; - operand.values[17] = tokenCoding6509_17; - operand.values[18] = tokenCoding6509_18; - operand.values[19] = tokenCoding6509_19; -} -x64Token x64Parser::tokenBranches6501[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502}, - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6509, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6500[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501}, {x64Token::EOT}}; -void x64Parser::TokenFunc6480(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 506; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7535(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 624; } -Coding x64Parser::tokenCoding6500_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7534[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7535, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7546(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 625; +} +x64Token x64Parser::tokenBranches7545[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7546, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7544[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6500_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7543[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6500(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6500_16; - operand.values[17] = tokenCoding6500_17; - operand.values[18] = tokenCoding6500_18; - operand.values[19] = tokenCoding6500_19; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6479[] = { - { - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc6480, - }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL, &x64Parser::TokenFunc6500, x64Parser::tokenBranches6500}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6474[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6473[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474}, {x64Token::EOT}}; -void x64Parser::TokenFunc6484(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 507; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6483[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6484, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6520_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding6520_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7533[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7543, x64Parser::tokenBranches7543 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7532[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7531[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7530[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7529[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7528[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7501[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7284[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6520_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 5}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6520(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6520_16; - operand.values[17] = tokenCoding6520_17; - operand.values[18] = tokenCoding6520_18; - operand.values[19] = tokenCoding6520_19; -} -x64Token x64Parser::tokenBranches6519[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6520, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6526_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7551_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6526(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6526_16; - operand.values[17] = tokenCoding6526_17; - operand.values[18] = tokenCoding6526_18; - operand.values[19] = tokenCoding6526_19; -} -x64Token x64Parser::tokenBranches6518[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519}, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6526, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6517[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518}, {x64Token::EOT}}; -void x64Parser::TokenFunc6488(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 508; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7551(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7551_16; + operand.values[17] = tokenCoding7551_17; + operand.values[18] = tokenCoding7551_18; + operand.values[19] = tokenCoding7551_19; } -Coding x64Parser::tokenCoding6517_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7550[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7551, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7549[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7548[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6517_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6517(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6517_16; - operand.values[17] = tokenCoding6517_17; - operand.values[18] = tokenCoding6517_18; - operand.values[19] = tokenCoding6517_19; -} -x64Token x64Parser::tokenBranches6487[] = { - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6488, - }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL, &x64Parser::TokenFunc6517, x64Parser::tokenBranches6517}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6482[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6481[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482}, {x64Token::EOT}}; -void x64Parser::TokenFunc6492(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 509; - operand.values[24] = new Coding[2]; - CleanupValues.push_back(operand.values[24]); - operand.values[24]->type = Coding::number; - operand.values[24]->val = operands.size(); - operand.values[24]->bits = 0; - operand.values[24]->field = 0; - operand.values[24]->unary = 0; - operand.values[24]->binary = 0; - operand.values[24][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6491[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6492, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6537_16[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_17[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_18[] = { - {CODING_NAME("isigned")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7555_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_19[] = { - {CODING_NAME("isigned") Coding::stateFunc, 6}, - {CODING_NAME("isigned")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6537(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 511; - operand.values[28] = new Coding[2]; - CleanupValues.push_back(operand.values[28]); - operand.values[28]->type = Coding::number; - operand.values[28]->val = operands.size(); - operand.values[28]->bits = 0; - operand.values[28]->field = 0; - operand.values[28]->unary = 0; - operand.values[28]->binary = 0; - operand.values[28][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6537_16; - operand.values[17] = tokenCoding6537_17; - operand.values[18] = tokenCoding6537_18; - operand.values[19] = tokenCoding6537_19; -} -x64Token x64Parser::tokenBranches6536[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6537, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6543_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7555(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7555_16; + operand.values[17] = tokenCoding7555_17; + operand.values[18] = tokenCoding7555_18; + operand.values[19] = tokenCoding7555_19; +} +x64Token x64Parser::tokenBranches7554[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7555, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7553[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7552[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6543(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding6543_16; - operand.values[17] = tokenCoding6543_17; - operand.values[18] = tokenCoding6543_18; - operand.values[19] = tokenCoding6543_19; -} -x64Token x64Parser::tokenBranches6535[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536}, - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6543, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6534[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535}, {x64Token::EOT}}; -void x64Parser::TokenFunc6496(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 510; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding6534_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7559_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6534(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7559(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6534_16; - operand.values[17] = tokenCoding6534_17; - operand.values[18] = tokenCoding6534_18; - operand.values[19] = tokenCoding6534_19; + operand.values[16] = tokenCoding7559_16; + operand.values[17] = tokenCoding7559_17; + operand.values[18] = tokenCoding7559_18; + operand.values[19] = tokenCoding7559_19; } -x64Token x64Parser::tokenBranches6495[] = { - { - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc6496, - }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL, &x64Parser::TokenFunc6534, x64Parser::tokenBranches6534}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6490[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6489[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6549_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7558[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7559, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7557[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7556[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6549(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6549_16; - operand.values[17] = tokenCoding6549_17; - operand.values[18] = tokenCoding6549_18; - operand.values[19] = tokenCoding6549_19; -} -x64Token x64Parser::tokenBranches6548[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6549, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6551_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6551_16; - operand.values[17] = tokenCoding6551_17; - operand.values[18] = tokenCoding6551_18; - operand.values[19] = tokenCoding6551_19; -} -x64Token x64Parser::tokenBranches6550[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6551, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6553_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7563_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7563_16; + operand.values[17] = tokenCoding7563_17; + operand.values[18] = tokenCoding7563_18; + operand.values[19] = tokenCoding7563_19; +} +x64Token x64Parser::tokenBranches7562[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7563, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7560[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6553_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6553(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6553_16; - operand.values[17] = tokenCoding6553_17; - operand.values[18] = tokenCoding6553_18; - operand.values[19] = tokenCoding6553_19; -} -x64Token x64Parser::tokenBranches6552[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6553, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6555_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7567_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7567_16; + operand.values[17] = tokenCoding7567_17; + operand.values[18] = tokenCoding7567_18; + operand.values[19] = tokenCoding7567_19; +} +x64Token x64Parser::tokenBranches7566[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7567, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7564[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6555_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7571_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6555(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6555_16; - operand.values[17] = tokenCoding6555_17; - operand.values[18] = tokenCoding6555_18; - operand.values[19] = tokenCoding6555_19; -} -x64Token x64Parser::tokenBranches6554[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6555, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6473(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc6481(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc6489(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6472[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc6473, x64Parser::tokenBranches6473}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc6481, x64Parser::tokenBranches6481}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc6489, x64Parser::tokenBranches6489}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6560(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 514; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6559[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6560, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6575(x64Operand& operand, int tokenPos) { operand.operandCoding = 518; } -x64Token x64Parser::tokenBranches6558[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6575, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6557[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558}, {x64Token::EOT}}; -void x64Parser::TokenFunc6564(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 515; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6563[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6564, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6578(x64Operand& operand, int tokenPos) { operand.operandCoding = 519; } -x64Token x64Parser::tokenBranches6562[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6578, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6561[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562}, {x64Token::EOT}}; -void x64Parser::TokenFunc6568(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 516; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6567[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6568, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6581(x64Operand& operand, int tokenPos) { operand.operandCoding = 520; } -x64Token x64Parser::tokenBranches6566[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6581, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6565[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566}, {x64Token::EOT}}; -void x64Parser::TokenFunc6572(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 517; - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6571[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6572, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6584(x64Operand& operand, int tokenPos) { operand.operandCoding = 521; } -x64Token x64Parser::tokenBranches6570[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571}, - { - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6584, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6569[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6556[] = {{x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6593(x64Operand& operand, int tokenPos) { operand.operandCoding = 522; } -x64Token x64Parser::tokenBranches6592[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6593, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6591[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6590[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591}, {x64Token::EOT}}; -void x64Parser::TokenFunc6609(x64Operand& operand, int tokenPos) { operand.operandCoding = 524; } -x64Token x64Parser::tokenBranches6608[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6609, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6607[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6606[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6589[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6588[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6587[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588}, {x64Token::EOT}}; -void x64Parser::TokenFunc6601(x64Operand& operand, int tokenPos) { operand.operandCoding = 523; } -x64Token x64Parser::tokenBranches6600[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6601, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6599[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6598[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599}, {x64Token::EOT}}; -void x64Parser::TokenFunc6617(x64Operand& operand, int tokenPos) { operand.operandCoding = 525; } -x64Token x64Parser::tokenBranches6616[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6617, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6615[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6614[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615}, {x64Token::EOT}}; -void x64Parser::TokenFunc6631(x64Operand& operand, int tokenPos) { operand.operandCoding = 527; } -x64Token x64Parser::tokenBranches6630[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6631, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6629[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6628[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6597[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6596[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597}, {x64Token::EOT}}; -void x64Parser::TokenFunc6623(x64Operand& operand, int tokenPos) { operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches6622[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6623, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6621[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6620[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621}, {x64Token::EOT}}; -void x64Parser::TokenFunc6596(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6595[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6596, x64Parser::tokenBranches6596}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6586[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6639(x64Operand& operand, int tokenPos) { operand.operandCoding = 528; } -x64Token x64Parser::tokenBranches6638[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6639, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6637[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6636[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637}, {x64Token::EOT}}; -void x64Parser::TokenFunc6655(x64Operand& operand, int tokenPos) { operand.operandCoding = 530; } -x64Token x64Parser::tokenBranches6654[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6655, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6653[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6652[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6635[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6634[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6633[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634}, {x64Token::EOT}}; -void x64Parser::TokenFunc6647(x64Operand& operand, int tokenPos) { operand.operandCoding = 529; } -x64Token x64Parser::tokenBranches6646[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6647, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6644[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645}, {x64Token::EOT}}; -void x64Parser::TokenFunc6663(x64Operand& operand, int tokenPos) { operand.operandCoding = 531; } -x64Token x64Parser::tokenBranches6662[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6663, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6661[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6660[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661}, {x64Token::EOT}}; -void x64Parser::TokenFunc6677(x64Operand& operand, int tokenPos) { operand.operandCoding = 533; } -x64Token x64Parser::tokenBranches6676[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6677, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6675[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6674[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6643[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6642[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643}, {x64Token::EOT}}; -void x64Parser::TokenFunc6669(x64Operand& operand, int tokenPos) { operand.operandCoding = 532; } -x64Token x64Parser::tokenBranches6668[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6669, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6667[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6666[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667}, {x64Token::EOT}}; -void x64Parser::TokenFunc6642(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6641[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6642, x64Parser::tokenBranches6642}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6632[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6685(x64Operand& operand, int tokenPos) { operand.operandCoding = 534; } -x64Token x64Parser::tokenBranches6684[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6685, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6683[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6682[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683}, {x64Token::EOT}}; -void x64Parser::TokenFunc6701(x64Operand& operand, int tokenPos) { operand.operandCoding = 536; } -x64Token x64Parser::tokenBranches6700[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6701, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6699[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6698[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6681[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6680[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6679[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680}, {x64Token::EOT}}; -void x64Parser::TokenFunc6693(x64Operand& operand, int tokenPos) { operand.operandCoding = 535; } -x64Token x64Parser::tokenBranches6692[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6693, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6691[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6690[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691}, {x64Token::EOT}}; -void x64Parser::TokenFunc6709(x64Operand& operand, int tokenPos) { operand.operandCoding = 537; } -x64Token x64Parser::tokenBranches6708[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6709, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6707[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6706[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707}, {x64Token::EOT}}; -void x64Parser::TokenFunc6723(x64Operand& operand, int tokenPos) { operand.operandCoding = 539; } -x64Token x64Parser::tokenBranches6722[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6723, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6721[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6720[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6689[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6688[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689}, {x64Token::EOT}}; -void x64Parser::TokenFunc6715(x64Operand& operand, int tokenPos) { operand.operandCoding = 538; } -x64Token x64Parser::tokenBranches6714[] = {{ - x64Token::REGISTER, - 20, - 1, - 0, - NULL, - &x64Parser::TokenFunc6715, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6713[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6712[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713}, {x64Token::EOT}}; -void x64Parser::TokenFunc6688(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +Coding x64Parser::tokenCoding7571_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7571_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7571_19[] = { + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7571_16; + operand.values[17] = tokenCoding7571_17; + operand.values[18] = tokenCoding7571_18; + operand.values[19] = tokenCoding7571_19; +} +x64Token x64Parser::tokenBranches7570[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7571, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7568[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6687[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6688, x64Parser::tokenBranches6688}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6678[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6585[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6730(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 540; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6729[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc6730, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6728[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6736_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7547[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7548, x64Parser::tokenBranches7548 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7552, x64Parser::tokenBranches7552 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7556, x64Parser::tokenBranches7556 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6736_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6736(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6736_16; - operand.values[17] = tokenCoding6736_17; - operand.values[18] = tokenCoding6736_18; - operand.values[19] = tokenCoding6736_19; -} -x64Token x64Parser::tokenBranches6735[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6736, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6740(x64Operand& operand, int tokenPos) { operand.operandCoding = 541; } -x64Token x64Parser::tokenBranches6739[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6740, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6748(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 542; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6747[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6748, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6750(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 543; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6749[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6750, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6761(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 544; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6760[] = {{ - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc6761, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6766(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 545; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6765[] = {{ - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6766, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6759[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6758[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6775_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_23[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7577_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6775(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6775_16; - operand.values[17] = tokenCoding6775_17; - operand.values[18] = tokenCoding6775_18; - operand.values[19] = tokenCoding6775_19; -} -x64Token x64Parser::tokenBranches6774[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6775, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6778_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7577_16; + operand.values[17] = tokenCoding7577_17; + operand.values[23] = tokenCoding7577_23; + operand.values[18] = tokenCoding7577_18; + operand.values[19] = tokenCoding7577_19; +} +x64Token x64Parser::tokenBranches7576[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7577, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6778(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6778_16; - operand.values[17] = tokenCoding6778_17; - operand.values[18] = tokenCoding6778_18; - operand.values[19] = tokenCoding6778_19; -} -x64Token x64Parser::tokenBranches6777[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6778, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6758(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::number; - operand.values[2]->val = operands.size(); - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6768(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 546; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6770(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 547; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -Coding x64Parser::tokenCoding6772_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7580_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding7580_16; + operand.values[17] = tokenCoding7580_17; + operand.values[23] = tokenCoding7580_23; + operand.values[18] = tokenCoding7580_18; + operand.values[19] = tokenCoding7580_19; +} +x64Token x64Parser::tokenBranches7579[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7580, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7578[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 626; +} +x64Token x64Parser::tokenBranches7574[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7575, x64Parser::tokenBranches7575 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7581, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6772(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6772_16; - operand.values[17] = tokenCoding6772_17; - operand.values[18] = tokenCoding6772_18; - operand.values[19] = tokenCoding6772_19; + operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches6757[] = { - {x64Token::NUMBER, 4, 0, 0, NULL, &x64Parser::TokenFunc6758, x64Parser::tokenBranches6758}, - { - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc6768, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc6770, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6772, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6780(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 548; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6779[] = {{ - x64Token::NUMBER, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc6780, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6782(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 549; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6784(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 550; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6781[] = {{ - x64Token::NUMBER, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc6782, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc6784, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6792_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7582[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7583, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6792_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6792(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6792_16; - operand.values[17] = tokenCoding6792_17; - operand.values[18] = tokenCoding6792_18; - operand.values[19] = tokenCoding6792_19; -} -x64Token x64Parser::tokenBranches6791[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6792, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6794_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7593_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7593_16; + operand.values[17] = tokenCoding7593_17; + operand.values[18] = tokenCoding7593_18; + operand.values[19] = tokenCoding7593_19; +} +x64Token x64Parser::tokenBranches7592[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7593, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6794_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6794(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6794_16; - operand.values[17] = tokenCoding6794_17; - operand.values[18] = tokenCoding6794_18; - operand.values[19] = tokenCoding6794_19; -} -x64Token x64Parser::tokenBranches6793[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6794, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6796_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7589_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6796(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6796_16; - operand.values[17] = tokenCoding6796_17; - operand.values[18] = tokenCoding6796_18; - operand.values[19] = tokenCoding6796_19; -} -x64Token x64Parser::tokenBranches6795[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6796, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6785(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 549; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6786(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 550; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7589_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7589_16; + operand.values[17] = tokenCoding7589_17; + operand.values[18] = tokenCoding7589_18; + operand.values[19] = tokenCoding7589_19; } -Coding x64Parser::tokenCoding6787_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7588[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7589, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6787_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7587[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6787_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7600_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7600_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7600_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7600_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6787(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6787_16; - operand.values[17] = tokenCoding6787_17; - operand.values[18] = tokenCoding6787_18; - operand.values[19] = tokenCoding6787_19; + operand.values[16] = tokenCoding7600_16; + operand.values[17] = tokenCoding7600_17; + operand.values[18] = tokenCoding7600_18; + operand.values[19] = tokenCoding7600_19; } -Coding x64Parser::tokenCoding6788_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7599[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7600, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6788_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7596_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7596_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7596_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7596_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7596(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7596_16; + operand.values[17] = tokenCoding7596_17; + operand.values[18] = tokenCoding7596_18; + operand.values[19] = tokenCoding7596_19; +} +x64Token x64Parser::tokenBranches7595[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7596, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7594[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7586[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7587, x64Parser::tokenBranches7587 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7594, x64Parser::tokenBranches7594 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7610(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 628; +} +x64Token x64Parser::tokenBranches7609[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7610, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6788_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7608[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6788(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6788_16; - operand.values[17] = tokenCoding6788_17; - operand.values[18] = tokenCoding6788_18; - operand.values[19] = tokenCoding6788_19; + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); } -Coding x64Parser::tokenCoding6789_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7607[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7608, x64Parser::tokenBranches7608 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 629; +} +x64Token x64Parser::tokenBranches7613[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7614, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7612[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6789_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7611[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7612, x64Parser::tokenBranches7612 }, + {x64Token::EOT } }; -void x64Parser::TokenFunc6789(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6789_16; - operand.values[17] = tokenCoding6789_17; - operand.values[18] = tokenCoding6789_18; - operand.values[19] = tokenCoding6789_19; + operand.operandCoding = 630; } -Coding x64Parser::tokenCoding6790_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7617[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7618, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7616[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7615[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7616, x64Parser::tokenBranches7616 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6790_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6790(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6790_16; - operand.values[17] = tokenCoding6790_17; - operand.values[18] = tokenCoding6790_18; - operand.values[19] = tokenCoding6790_19; -} -x64Token x64Parser::tokenBranches6756[] = {{x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757}, - {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779}, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781}, - { - x64Token::NUMBER, - 13, - 1, - 0, - NULL, - &x64Parser::TokenFunc6785, - }, - { - x64Token::NUMBER, - 15, - 1, - 0, - NULL, - &x64Parser::TokenFunc6786, - }, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc6787, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6788, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc6789, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6790, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6830_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 631; +} +x64Token x64Parser::tokenBranches7621[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7622, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7620[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) +{ + operand.values[29] = new Coding[2]; + CleanupValues.push_back(operand.values[29]); + operand.values[29]->type = Coding::number; + operand.values[29]->val = operands.size(); + operand.values[29]->bits = 0; + operand.values[29]->field = 0; + operand.values[29]->unary = 0; + operand.values[29]->binary = 0; + operand.values[29][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7619[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7620, x64Parser::tokenBranches7620 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6830_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6830(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6830_16; - operand.values[17] = tokenCoding6830_17; - operand.values[18] = tokenCoding6830_18; - operand.values[19] = tokenCoding6830_19; -} -x64Token x64Parser::tokenBranches6829[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc6830, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6837(x64Operand& operand, int tokenPos) { operand.operandCoding = 551; } -x64Token x64Parser::tokenBranches6836[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6837, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6849(x64Operand& operand, int tokenPos) { operand.operandCoding = 553; } -x64Token x64Parser::tokenBranches6848[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6849, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6835[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6834[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835}, {x64Token::EOT}}; -void x64Parser::TokenFunc6843(x64Operand& operand, int tokenPos) { operand.operandCoding = 552; } -x64Token x64Parser::tokenBranches6842[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6843, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6855(x64Operand& operand, int tokenPos) { operand.operandCoding = 554; } -x64Token x64Parser::tokenBranches6854[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6855, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6865(x64Operand& operand, int tokenPos) { operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches6864[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6865, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6841[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6840[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841}, {x64Token::EOT}}; -void x64Parser::TokenFunc6859(x64Operand& operand, int tokenPos) { operand.operandCoding = 555; } -x64Token x64Parser::tokenBranches6858[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6859, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6840(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7625(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 632; } -x64Token x64Parser::tokenBranches6833[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6840, x64Parser::tokenBranches6840}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6832[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833}, {x64Token::EOT}}; -void x64Parser::TokenFunc6871(x64Operand& operand, int tokenPos) { operand.operandCoding = 557; } -x64Token x64Parser::tokenBranches6870[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6871, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6883(x64Operand& operand, int tokenPos) { operand.operandCoding = 559; } -x64Token x64Parser::tokenBranches6882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6883, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6869[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6868[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869}, {x64Token::EOT}}; -void x64Parser::TokenFunc6877(x64Operand& operand, int tokenPos) { operand.operandCoding = 558; } -x64Token x64Parser::tokenBranches6876[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6877, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6889(x64Operand& operand, int tokenPos) { operand.operandCoding = 560; } -x64Token x64Parser::tokenBranches6888[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6889, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6899(x64Operand& operand, int tokenPos) { operand.operandCoding = 562; } -x64Token x64Parser::tokenBranches6898[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6899, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6875[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6874[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875}, {x64Token::EOT}}; -void x64Parser::TokenFunc6893(x64Operand& operand, int tokenPos) { operand.operandCoding = 561; } -x64Token x64Parser::tokenBranches6892[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6893, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6874(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 633; } -x64Token x64Parser::tokenBranches6867[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6874, x64Parser::tokenBranches6874}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6866[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867}, {x64Token::EOT}}; -void x64Parser::TokenFunc6905(x64Operand& operand, int tokenPos) { operand.operandCoding = 563; } -x64Token x64Parser::tokenBranches6904[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6905, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6917(x64Operand& operand, int tokenPos) { operand.operandCoding = 565; } -x64Token x64Parser::tokenBranches6916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6917, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6903[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6902[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903}, {x64Token::EOT}}; -void x64Parser::TokenFunc6911(x64Operand& operand, int tokenPos) { operand.operandCoding = 564; } -x64Token x64Parser::tokenBranches6910[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6911, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6923(x64Operand& operand, int tokenPos) { operand.operandCoding = 566; } -x64Token x64Parser::tokenBranches6922[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6923, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6933(x64Operand& operand, int tokenPos) { operand.operandCoding = 568; } -x64Token x64Parser::tokenBranches6932[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6933, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6909[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6908[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909}, {x64Token::EOT}}; -void x64Parser::TokenFunc6927(x64Operand& operand, int tokenPos) { operand.operandCoding = 567; } -x64Token x64Parser::tokenBranches6926[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6927, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6908(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 634; } -x64Token x64Parser::tokenBranches6901[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6908, x64Parser::tokenBranches6908}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6900[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901}, {x64Token::EOT}}; -void x64Parser::TokenFunc6939(x64Operand& operand, int tokenPos) { operand.operandCoding = 569; } -x64Token x64Parser::tokenBranches6938[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6939, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6937[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6936[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937}, {x64Token::EOT}}; -void x64Parser::TokenFunc6945(x64Operand& operand, int tokenPos) { operand.operandCoding = 570; } -x64Token x64Parser::tokenBranches6944[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6945, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6955(x64Operand& operand, int tokenPos) { operand.operandCoding = 572; } -x64Token x64Parser::tokenBranches6954[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6955, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6943[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6942[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943}, {x64Token::EOT}}; -void x64Parser::TokenFunc6949(x64Operand& operand, int tokenPos) { operand.operandCoding = 571; } -x64Token x64Parser::tokenBranches6948[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6949, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6942(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches6935[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6942, x64Parser::tokenBranches6942}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6934[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6831[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934}, - {x64Token::EOT}}; -void x64Parser::TokenFunc6960(x64Operand& operand, int tokenPos) { operand.operandCoding = 573; } -x64Token x64Parser::tokenBranches6959[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc6960, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6962(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 574; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6961[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6962, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6964(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 575; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6963[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6964, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6966(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 576; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6965[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6966, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6968(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 576; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6967[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6968, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6970(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 575; - operand.values[11] = new Coding[2]; - CleanupValues.push_back(operand.values[11]); - operand.values[11]->type = Coding::number; - operand.values[11]->val = operands.size(); - operand.values[11]->bits = 0; - operand.values[11]->field = 0; - operand.values[11]->unary = 0; - operand.values[11]->binary = 0; - operand.values[11][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches6969[] = {{ - x64Token::NUMBER, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc6970, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6974_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7624[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7625, }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7628, }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7631, }, + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7634, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7623[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7606[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619 }, + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6974(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6974_16; - operand.values[17] = tokenCoding6974_17; - operand.values[18] = tokenCoding6974_18; - operand.values[19] = tokenCoding6974_19; -} -x64Token x64Parser::tokenBranches6973[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc6974, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding6978_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7643(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 636; +} +x64Token x64Parser::tokenBranches7642[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7643, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7659(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 638; +} +x64Token x64Parser::tokenBranches7658[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7659, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7641[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6978(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6978_16; - operand.values[17] = tokenCoding6978_17; - operand.values[18] = tokenCoding6978_18; - operand.values[19] = tokenCoding6978_19; -} -x64Token x64Parser::tokenBranches6977[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6978, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6976[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6981_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7640[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7651(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 637; +} +x64Token x64Parser::tokenBranches7650[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7651, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7667(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 639; +} +x64Token x64Parser::tokenBranches7666[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7667, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6981(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6981_16; - operand.values[17] = tokenCoding6981_17; - operand.values[18] = tokenCoding6981_18; - operand.values[19] = tokenCoding6981_19; -} -x64Token x64Parser::tokenBranches6980[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6981, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6979[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding6984_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7681(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 641; +} +x64Token x64Parser::tokenBranches7680[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7681, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7649[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7648[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc6984(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding6984_16; - operand.values[17] = tokenCoding6984_17; - operand.values[18] = tokenCoding6984_18; - operand.values[19] = tokenCoding6984_19; -} -x64Token x64Parser::tokenBranches6983[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc6984, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6982[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983}, {x64Token::EOT}}; -void x64Parser::TokenFunc6990(x64Operand& operand, int tokenPos) { operand.operandCoding = 577; } -x64Token x64Parser::tokenBranches6989[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6990, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6998(x64Operand& operand, int tokenPos) { operand.operandCoding = 578; } -x64Token x64Parser::tokenBranches6997[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc6998, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7012(x64Operand& operand, int tokenPos) { operand.operandCoding = 580; } -x64Token x64Parser::tokenBranches7011[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7012, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6997(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7011(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches6996[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc6997, x64Parser::tokenBranches6997}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7011, x64Parser::tokenBranches7011}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6995[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996}, {x64Token::EOT}}; -void x64Parser::TokenFunc7004(x64Operand& operand, int tokenPos) { operand.operandCoding = 579; } -x64Token x64Parser::tokenBranches7003[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7004, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc6989(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc6995(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7003(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7672[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6988[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc6989, x64Parser::tokenBranches6989}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc6995, x64Parser::tokenBranches6995}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7003, x64Parser::tokenBranches7003}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6987[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6986[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches6985[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986}, {x64Token::EOT}}; -void x64Parser::TokenFunc7018(x64Operand& operand, int tokenPos) { operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches7017[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7018, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7026(x64Operand& operand, int tokenPos) { operand.operandCoding = 582; } -x64Token x64Parser::tokenBranches7025[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7026, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7040(x64Operand& operand, int tokenPos) { operand.operandCoding = 584; } -x64Token x64Parser::tokenBranches7039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7025(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7039(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7639[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7648, x64Parser::tokenBranches7648 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7638[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7689(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7024[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7025, x64Parser::tokenBranches7025}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7039, x64Parser::tokenBranches7039}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7023[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024}, {x64Token::EOT}}; -void x64Parser::TokenFunc7032(x64Operand& operand, int tokenPos) { operand.operandCoding = 583; } -x64Token x64Parser::tokenBranches7031[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7032, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7017(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7023(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7031(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7688[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7689, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7705(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7016[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7017, x64Parser::tokenBranches7017}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7023, x64Parser::tokenBranches7023}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7031, x64Parser::tokenBranches7031}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7015[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7014[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7013[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014}, {x64Token::EOT}}; -void x64Parser::TokenFunc7046(x64Operand& operand, int tokenPos) { operand.operandCoding = 585; } -x64Token x64Parser::tokenBranches7045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7046, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7054(x64Operand& operand, int tokenPos) { operand.operandCoding = 586; } -x64Token x64Parser::tokenBranches7053[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7054, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7068(x64Operand& operand, int tokenPos) { operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches7067[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7068, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7053(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7067(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7704[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7705, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7687[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7686[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7697(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7052[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7053, x64Parser::tokenBranches7053}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7067, x64Parser::tokenBranches7067}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7051[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052}, {x64Token::EOT}}; -void x64Parser::TokenFunc7060(x64Operand& operand, int tokenPos) { operand.operandCoding = 587; } -x64Token x64Parser::tokenBranches7059[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7060, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7045(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7051(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7059(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7696[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7697, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7713(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7044[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7045, x64Parser::tokenBranches7045}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7051, x64Parser::tokenBranches7051}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7059, x64Parser::tokenBranches7059}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7043[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7042[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7041[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042}, {x64Token::EOT}}; -void x64Parser::TokenFunc7072(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 589; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches7712[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7713, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7727(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 647; } -Coding x64Parser::tokenCoding7092_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7726[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7727, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7695[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7694[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7092_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7092(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7092_16; - operand.values[17] = tokenCoding7092_17; - operand.values[18] = tokenCoding7092_18; - operand.values[19] = tokenCoding7092_19; -} -x64Token x64Parser::tokenBranches7071[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7072, - }, - { - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7092, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7070[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7069[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070}, {x64Token::EOT}}; -void x64Parser::TokenFunc7076(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 590; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 646; } -Coding x64Parser::tokenCoding7096_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7718[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7685[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7694, x64Parser::tokenBranches7694 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7684[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7735(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 648; +} +x64Token x64Parser::tokenBranches7734[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7735, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7096_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7096(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7096_16; - operand.values[17] = tokenCoding7096_17; - operand.values[23] = tokenCoding7096_23; - operand.values[18] = tokenCoding7096_18; - operand.values[19] = tokenCoding7096_19; -} -x64Token x64Parser::tokenBranches7075[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7076, - }, - { - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7096, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7074[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7073[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074}, {x64Token::EOT}}; -void x64Parser::TokenFunc7080(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 591; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7751(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 650; } -Coding x64Parser::tokenCoding7100_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7750[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7751, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7733[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7732[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7100_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7100(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7100_16; - operand.values[17] = tokenCoding7100_17; - operand.values[18] = tokenCoding7100_18; - operand.values[19] = tokenCoding7100_19; -} -x64Token x64Parser::tokenBranches7079[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7080, - }, - { - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7100, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7078[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7077[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078}, {x64Token::EOT}}; -void x64Parser::TokenFunc7084(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 592; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7743(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 649; } -Coding x64Parser::tokenCoding7104_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding7104_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding x64Parser::tokenCoding7104_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7742[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7743, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7104_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7104(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7104_16; - operand.values[17] = tokenCoding7104_17; - operand.values[18] = tokenCoding7104_18; - operand.values[19] = tokenCoding7104_19; -} -x64Token x64Parser::tokenBranches7083[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7084, - }, - { - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7104, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7082[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7081[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082}, {x64Token::EOT}}; -void x64Parser::TokenFunc7088(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 593; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7759(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 651; } -Coding x64Parser::tokenCoding7108_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7758[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7759, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7773(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 653; +} +x64Token x64Parser::tokenBranches7772[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7773, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7741[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7108_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7108(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7108_16; - operand.values[17] = tokenCoding7108_17; - operand.values[18] = tokenCoding7108_18; - operand.values[19] = tokenCoding7108_19; -} -x64Token x64Parser::tokenBranches7087[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7088, - }, - { - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7108, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7086[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7085[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7113_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7740[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 652; +} +x64Token x64Parser::tokenBranches7764[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7731[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7740, x64Parser::tokenBranches7740 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7113(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7113_16; - operand.values[17] = tokenCoding7113_17; - operand.values[18] = tokenCoding7113_18; - operand.values[19] = tokenCoding7113_19; -} -x64Token x64Parser::tokenBranches7112[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7113, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7111[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7110[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7109[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7118_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7730[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7637[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7636[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7118(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7118_16; - operand.values[17] = tokenCoding7118_17; - operand.values[18] = tokenCoding7118_18; - operand.values[19] = tokenCoding7118_19; -} -x64Token x64Parser::tokenBranches7117[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7118, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7116[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7115[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7114[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7123_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7635[] = { + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7123_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7123(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7123_16; - operand.values[17] = tokenCoding7123_17; - operand.values[18] = tokenCoding7123_18; - operand.values[19] = tokenCoding7123_19; -} -x64Token x64Parser::tokenBranches7122[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7123, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7121[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7120[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7119[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7128_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7782_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7782(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7782_16; + operand.values[17] = tokenCoding7782_17; + operand.values[18] = tokenCoding7782_18; + operand.values[19] = tokenCoding7782_19; +} +x64Token x64Parser::tokenBranches7781[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7782, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7128_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7128(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding7128_16; - operand.values[17] = tokenCoding7128_17; - operand.values[18] = tokenCoding7128_18; - operand.values[19] = tokenCoding7128_19; -} -x64Token x64Parser::tokenBranches7127[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7128, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7126[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7125[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7124[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7279_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7279_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7279(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7279_18; - operand.values[19] = tokenCoding7279_19; -} -x64Token x64Parser::tokenBranches7278[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7279, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7131_16[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_17[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_18[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7784_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_19[] = { - {CODING_NAME("creg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("creg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7131(x64Operand& operand, int tokenPos) -{ - operand.values[30] = new Coding[2]; - CleanupValues.push_back(operand.values[30]); - operand.values[30]->type = Coding::reg; - operand.values[30]->val = inputTokens[tokenPos]->val->ival; - operand.values[30]->bits = 0; - operand.values[30]->field = 0; - operand.values[30]->unary = 0; - operand.values[30]->binary = 0; - operand.values[30][1].type = Coding::eot; - operand.values[16] = tokenCoding7131_16; - operand.values[17] = tokenCoding7131_17; - operand.values[18] = tokenCoding7131_18; - operand.values[19] = tokenCoding7131_19; +void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7784_16; + operand.values[17] = tokenCoding7784_17; + operand.values[18] = tokenCoding7784_18; + operand.values[19] = tokenCoding7784_19; } -Coding x64Parser::tokenCoding7134_16[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7783[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7784, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7134_17[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_18[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_19[] = { - {CODING_NAME("dreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7134(x64Operand& operand, int tokenPos) -{ - operand.values[31] = new Coding[2]; - CleanupValues.push_back(operand.values[31]); - operand.values[31]->type = Coding::reg; - operand.values[31]->val = inputTokens[tokenPos]->val->ival; - operand.values[31]->bits = 0; - operand.values[31]->field = 0; - operand.values[31]->unary = 0; - operand.values[31]->binary = 0; - operand.values[31][1].type = Coding::eot; - operand.values[16] = tokenCoding7134_16; - operand.values[17] = tokenCoding7134_17; - operand.values[18] = tokenCoding7134_18; - operand.values[19] = tokenCoding7134_19; -} -Coding x64Parser::tokenCoding7137_16[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_17[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7786_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding7786_16; + operand.values[17] = tokenCoding7786_17; + operand.values[18] = tokenCoding7786_18; + operand.values[19] = tokenCoding7786_19; +} +x64Token x64Parser::tokenBranches7785[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7786, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 654; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 655; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 656; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7787(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 657; +} +void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 658; +} +void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 659; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7777[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7778, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7779, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7780, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7787, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7788, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7789, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7137_18[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_19[] = { - {CODING_NAME("treg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("treg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7137(x64Operand& operand, int tokenPos) -{ - operand.values[32] = new Coding[2]; - CleanupValues.push_back(operand.values[32]); - operand.values[32]->type = Coding::reg; - operand.values[32]->val = inputTokens[tokenPos]->val->ival; - operand.values[32]->bits = 0; - operand.values[32]->field = 0; - operand.values[32]->unary = 0; - operand.values[32]->binary = 0; - operand.values[32][1].type = Coding::eot; - operand.values[16] = tokenCoding7137_16; - operand.values[17] = tokenCoding7137_17; - operand.values[18] = tokenCoding7137_18; - operand.values[19] = tokenCoding7137_19; -} -Coding x64Parser::tokenCoding7264_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7799_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7264(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7264_16; - operand.values[17] = tokenCoding7264_17; - operand.values[18] = tokenCoding7264_18; - operand.values[19] = tokenCoding7264_19; -} -x64Token x64Parser::tokenBranches7130[] = {{ - x64Token::REGISTERCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc7131, - }, - { - x64Token::REGISTERCLASS, - 22, - 1, - 0, - NULL, - &x64Parser::TokenFunc7134, - }, - { - x64Token::REGISTERCLASS, - 23, - 1, - 0, - NULL, - &x64Parser::TokenFunc7137, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7264, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7129[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130}, {x64Token::EOT}}; -void x64Parser::TokenFunc7143(x64Operand& operand, int tokenPos) { operand.operandCoding = 594; } -x64Token x64Parser::tokenBranches7142[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7143, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7141[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7140[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141}, {x64Token::EOT}}; -void x64Parser::TokenFunc7151(x64Operand& operand, int tokenPos) { operand.operandCoding = 595; } -x64Token x64Parser::tokenBranches7150[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7151, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7149[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7148[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149}, {x64Token::EOT}}; -void x64Parser::TokenFunc7165(x64Operand& operand, int tokenPos) { operand.operandCoding = 597; } -x64Token x64Parser::tokenBranches7164[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7165, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7163[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7162[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163}, {x64Token::EOT}}; -void x64Parser::TokenFunc7148(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7162(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7147[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7148, x64Parser::tokenBranches7148}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7162, x64Parser::tokenBranches7162}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7146[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147}, {x64Token::EOT}}; -void x64Parser::TokenFunc7157(x64Operand& operand, int tokenPos) { operand.operandCoding = 596; } -x64Token x64Parser::tokenBranches7156[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7157, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7155[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7154[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155}, {x64Token::EOT}}; -void x64Parser::TokenFunc7140(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7146(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7154(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7799_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7799_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7799(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7799_34; + operand.values[16] = tokenCoding7799_16; + operand.values[17] = tokenCoding7799_17; + operand.values[35] = tokenCoding7799_35; + operand.values[18] = tokenCoding7799_18; + operand.values[19] = tokenCoding7799_19; } -x64Token x64Parser::tokenBranches7139[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7140, x64Parser::tokenBranches7140}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7146, x64Parser::tokenBranches7146}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7154, x64Parser::tokenBranches7154}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7225_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7798[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7799, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7225_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7225(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7225_16; - operand.values[17] = tokenCoding7225_17; - operand.values[18] = tokenCoding7225_18; - operand.values[19] = tokenCoding7225_19; -} -Coding x64Parser::tokenCoding7229_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7801_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7229(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7229_16; - operand.values[17] = tokenCoding7229_17; - operand.values[23] = tokenCoding7229_23; - operand.values[18] = tokenCoding7229_18; - operand.values[19] = tokenCoding7229_19; -} -x64Token x64Parser::tokenBranches7224[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7225, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc7229, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7223[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7138[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7171(x64Operand& operand, int tokenPos) { operand.operandCoding = 598; } -x64Token x64Parser::tokenBranches7170[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7171, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7169[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7168[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169}, {x64Token::EOT}}; -void x64Parser::TokenFunc7179(x64Operand& operand, int tokenPos) { operand.operandCoding = 599; } -x64Token x64Parser::tokenBranches7178[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7179, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7177[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7176[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177}, {x64Token::EOT}}; -void x64Parser::TokenFunc7193(x64Operand& operand, int tokenPos) { operand.operandCoding = 601; } -x64Token x64Parser::tokenBranches7192[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7193, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7191[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7190[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191}, {x64Token::EOT}}; -void x64Parser::TokenFunc7176(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7190(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7175[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7176, x64Parser::tokenBranches7176}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7190, x64Parser::tokenBranches7190}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7174[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175}, {x64Token::EOT}}; -void x64Parser::TokenFunc7185(x64Operand& operand, int tokenPos) { operand.operandCoding = 600; } -x64Token x64Parser::tokenBranches7184[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7185, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7183[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7182[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183}, {x64Token::EOT}}; -void x64Parser::TokenFunc7168(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7174(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7182(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc7801(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7801_34; + operand.values[16] = tokenCoding7801_16; + operand.values[17] = tokenCoding7801_17; + operand.values[35] = tokenCoding7801_35; + operand.values[18] = tokenCoding7801_18; + operand.values[19] = tokenCoding7801_19; } -x64Token x64Parser::tokenBranches7167[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7168, x64Parser::tokenBranches7168}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7174, x64Parser::tokenBranches7174}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7182, x64Parser::tokenBranches7182}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7233_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7800[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7801, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7233_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7233(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7233_16; - operand.values[17] = tokenCoding7233_17; - operand.values[18] = tokenCoding7233_18; - operand.values[19] = tokenCoding7233_19; -} -Coding x64Parser::tokenCoding7258_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7803_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7258(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7258_16; - operand.values[17] = tokenCoding7258_17; - operand.values[18] = tokenCoding7258_18; - operand.values[19] = tokenCoding7258_19; -} -x64Token x64Parser::tokenBranches7232[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7233, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7258, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7231[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7166[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7199(x64Operand& operand, int tokenPos) { operand.operandCoding = 602; } -x64Token x64Parser::tokenBranches7198[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7199, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7196[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197}, {x64Token::EOT}}; -void x64Parser::TokenFunc7207(x64Operand& operand, int tokenPos) { operand.operandCoding = 603; } -x64Token x64Parser::tokenBranches7206[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7207, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7205[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7204[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205}, {x64Token::EOT}}; -void x64Parser::TokenFunc7221(x64Operand& operand, int tokenPos) { operand.operandCoding = 605; } -x64Token x64Parser::tokenBranches7220[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7221, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7219[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7218[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219}, {x64Token::EOT}}; -void x64Parser::TokenFunc7204(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7218(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7203[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7204, x64Parser::tokenBranches7204}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7218, x64Parser::tokenBranches7218}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7202[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203}, {x64Token::EOT}}; -void x64Parser::TokenFunc7213(x64Operand& operand, int tokenPos) { operand.operandCoding = 604; } -x64Token x64Parser::tokenBranches7212[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7213, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7211[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7212}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7210[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211}, {x64Token::EOT}}; -void x64Parser::TokenFunc7196(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7202(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -void x64Parser::TokenFunc7210(x64Operand& operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +Coding x64Parser::tokenCoding7803_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7803(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7803_34; + operand.values[16] = tokenCoding7803_16; + operand.values[17] = tokenCoding7803_17; + operand.values[35] = tokenCoding7803_35; + operand.values[18] = tokenCoding7803_18; + operand.values[19] = tokenCoding7803_19; } -x64Token x64Parser::tokenBranches7195[] = { - {x64Token::NUMBER, 6, 0, 0, NULL, &x64Parser::TokenFunc7196, x64Parser::tokenBranches7196}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7202, x64Parser::tokenBranches7202}, - {x64Token::NUMBER, 7, 0, 0, NULL, &x64Parser::TokenFunc7210, x64Parser::tokenBranches7210}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7237_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7802[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7803, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7237_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_34[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7237(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7237_16; - operand.values[17] = tokenCoding7237_17; - operand.values[18] = tokenCoding7237_18; - operand.values[19] = tokenCoding7237_19; -} -x64Token x64Parser::tokenBranches7236[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7237, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7235[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7194[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7241_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_35[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7241(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7241_16; - operand.values[17] = tokenCoding7241_17; - operand.values[18] = tokenCoding7241_18; - operand.values[19] = tokenCoding7241_19; -} -x64Token x64Parser::tokenBranches7240[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7241, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7239[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7238[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7245_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7805_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) +{ + operand.values[34] = tokenCoding7805_34; + operand.values[16] = tokenCoding7805_16; + operand.values[17] = tokenCoding7805_17; + operand.values[35] = tokenCoding7805_35; + operand.values[18] = tokenCoding7805_18; + operand.values[19] = tokenCoding7805_19; +} +x64Token x64Parser::tokenBranches7804[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7811(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 663; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7810[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 664; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7822_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7245(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7245_16; - operand.values[17] = tokenCoding7245_17; - operand.values[18] = tokenCoding7245_18; - operand.values[19] = tokenCoding7245_19; -} -x64Token x64Parser::tokenBranches7244[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7245, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7248_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7822_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 667; + operand.values[16] = tokenCoding7822_16; + operand.values[17] = tokenCoding7822_17; + operand.values[18] = tokenCoding7822_18; + operand.values[19] = tokenCoding7822_19; +} +x64Token x64Parser::tokenBranches7815[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7816, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7822, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 665; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7824_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7824_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7824_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7824_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 668; + operand.values[16] = tokenCoding7824_16; + operand.values[17] = tokenCoding7824_17; + operand.values[18] = tokenCoding7824_18; + operand.values[19] = tokenCoding7824_19; +} +x64Token x64Parser::tokenBranches7817[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7818, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7824, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 666; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +Coding x64Parser::tokenCoding7826_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7826_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding7826_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7248(x64Operand& operand, int tokenPos) +Coding x64Parser::tokenCoding7826_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7826(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 668; + operand.values[16] = tokenCoding7826_16; + operand.values[17] = tokenCoding7826_17; + operand.values[18] = tokenCoding7826_18; + operand.values[19] = tokenCoding7826_19; +} +x64Token x64Parser::tokenBranches7819[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7820, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7826, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 660; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 661; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 662; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 664; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 665; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 666; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7827(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; +} +void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 670; +} +void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 671; + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7806[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7807, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7808, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7809, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7812, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7813, }, + {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7814, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7827, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7828, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7829, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 672; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7844(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 673; +} +x64Token x64Parser::tokenBranches7842[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7843, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7844, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 674; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7847(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 675; +} +x64Token x64Parser::tokenBranches7845[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7846, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7847, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7861(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7248_16; - operand.values[17] = tokenCoding7248_17; - operand.values[18] = tokenCoding7248_18; - operand.values[19] = tokenCoding7248_19; + operand.operandCoding = 676; +} +x64Token x64Parser::tokenBranches7860[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7861, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 678; } -Coding x64Parser::tokenCoding7251_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7872[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7859[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7858[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7251_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7857[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 677; +} +x64Token x64Parser::tokenBranches7866[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, + {x64Token::EOT } }; -void x64Parser::TokenFunc7251(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7251_16; - operand.values[17] = tokenCoding7251_17; - operand.values[18] = tokenCoding7251_18; - operand.values[19] = tokenCoding7251_19; + operand.operandCoding = 679; } -Coding x64Parser::tokenCoding7254_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7878[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 681; +} +x64Token x64Parser::tokenBranches7888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7865[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7254_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7254(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7254_16; - operand.values[17] = tokenCoding7254_17; - operand.values[18] = tokenCoding7254_18; - operand.values[19] = tokenCoding7254_19; -} -x64Token x64Parser::tokenBranches7243[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244}, - { - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc7248, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7251, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc7254, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7242[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7275_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7864[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7275_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7275_18; - operand.values[19] = tokenCoding7275_19; -} -x64Token x64Parser::tokenBranches7274[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7275, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7261_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7883(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 680; +} +x64Token x64Parser::tokenBranches7882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7883, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7863[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7864, x64Parser::tokenBranches7864 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7856[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_19[] = { - {CODING_NAME("segm") Coding::stateFunc, 4}, - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7261(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7261_16; - operand.values[17] = tokenCoding7261_17; - operand.values[18] = tokenCoding7261_18; - operand.values[19] = tokenCoding7261_19; -} -x64Token x64Parser::tokenBranches7260[] = {{ - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7261, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7259[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7283_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 682; +} +x64Token x64Parser::tokenBranches7894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7283_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7283(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7283_18; - operand.values[19] = tokenCoding7283_19; -} -x64Token x64Parser::tokenBranches7282[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7283, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7267_16[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 684; +} +x64Token x64Parser::tokenBranches7906[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_17[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7893[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_18[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7892[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_19[] = { - {CODING_NAME("segm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7267(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7267_16; - operand.values[17] = tokenCoding7267_17; - operand.values[18] = tokenCoding7267_18; - operand.values[19] = tokenCoding7267_19; -} -x64Token x64Parser::tokenBranches7266[] = {{ - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7267, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7265[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7271_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7891[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7271_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7271(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[18] = tokenCoding7271_18; - operand.values[19] = tokenCoding7271_19; -} -x64Token x64Parser::tokenBranches7270[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7271, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7269[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7268[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269}, {x64Token::EOT}}; -void x64Parser::TokenFunc6976(x64Operand& operand, int tokenPos) -{ - operand.values[30] = new Coding[2]; - CleanupValues.push_back(operand.values[30]); - operand.values[30]->type = Coding::reg; - operand.values[30]->val = inputTokens[tokenPos]->val->ival; - operand.values[30]->bits = 0; - operand.values[30]->field = 0; - operand.values[30]->unary = 0; - operand.values[30]->binary = 0; - operand.values[30][1].type = Coding::eot; -} -void x64Parser::TokenFunc6979(x64Operand& operand, int tokenPos) -{ - operand.values[31] = new Coding[2]; - CleanupValues.push_back(operand.values[31]); - operand.values[31]->type = Coding::reg; - operand.values[31]->val = inputTokens[tokenPos]->val->ival; - operand.values[31]->bits = 0; - operand.values[31]->field = 0; - operand.values[31]->unary = 0; - operand.values[31]->binary = 0; - operand.values[31][1].type = Coding::eot; -} -void x64Parser::TokenFunc6982(x64Operand& operand, int tokenPos) -{ - operand.values[32] = new Coding[2]; - CleanupValues.push_back(operand.values[32]); - operand.values[32]->type = Coding::reg; - operand.values[32]->val = inputTokens[tokenPos]->val->ival; - operand.values[32]->bits = 0; - operand.values[32]->field = 0; - operand.values[32]->unary = 0; - operand.values[32]->binary = 0; - operand.values[32][1].type = Coding::eot; -} -void x64Parser::TokenFunc7069(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7073(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7077(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7081(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7085(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7242(x64Operand& operand, int tokenPos) -{ - operand.values[33] = new Coding[2]; - CleanupValues.push_back(operand.values[33]); - operand.values[33]->type = Coding::reg; - operand.values[33]->val = inputTokens[tokenPos]->val->ival; - operand.values[33]->bits = 0; - operand.values[33]->field = 0; - operand.values[33]->unary = 0; - operand.values[33]->binary = 0; - operand.values[33][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches6975[] = { - {x64Token::REGISTERCLASS, 21, 0, 0, NULL, &x64Parser::TokenFunc6976, x64Parser::tokenBranches6976}, - {x64Token::REGISTERCLASS, 22, 0, 0, NULL, &x64Parser::TokenFunc6979, x64Parser::tokenBranches6979}, - {x64Token::REGISTERCLASS, 23, 0, 0, NULL, &x64Parser::TokenFunc6982, x64Parser::tokenBranches6982}, - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc7069, x64Parser::tokenBranches7069}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc7073, x64Parser::tokenBranches7073}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc7077, x64Parser::tokenBranches7077}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7081, x64Parser::tokenBranches7081}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7085, x64Parser::tokenBranches7085}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7242, x64Parser::tokenBranches7242}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7297(x64Operand& operand, int tokenPos) { operand.operandCoding = 606; } -x64Token x64Parser::tokenBranches7296[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7297, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7295[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7294[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295}, {x64Token::EOT}}; -void x64Parser::TokenFunc7310(x64Operand& operand, int tokenPos) { operand.operandCoding = 607; } -x64Token x64Parser::tokenBranches7309[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7310, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7308[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7307[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308}, {x64Token::EOT}}; -void x64Parser::TokenFunc7307(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7293[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7307, x64Parser::tokenBranches7307}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7292[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7291[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7290[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7289[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290}, {x64Token::EOT}}; -void x64Parser::TokenFunc7323(x64Operand& operand, int tokenPos) { operand.operandCoding = 608; } -x64Token x64Parser::tokenBranches7322[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7323, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7321[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7320[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321}, {x64Token::EOT}}; -void x64Parser::TokenFunc7336(x64Operand& operand, int tokenPos) { operand.operandCoding = 609; } -x64Token x64Parser::tokenBranches7335[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7336, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7334[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7333[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334}, {x64Token::EOT}}; -void x64Parser::TokenFunc7333(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7319[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7333, x64Parser::tokenBranches7333}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7318[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7317[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7316[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7315[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7288[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7287[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7286[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287}, {x64Token::EOT}}; -void x64Parser::TokenFunc7345(x64Operand& operand, int tokenPos) { operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches7344[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7345, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7356(x64Operand& operand, int tokenPos) { operand.operandCoding = 611; } -x64Token x64Parser::tokenBranches7355[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7356, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7354[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7353[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354}, {x64Token::EOT}}; -void x64Parser::TokenFunc7353(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7343[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7353, x64Parser::tokenBranches7353}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7342[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7341[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7340[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7339[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7338[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7285[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7369(x64Operand& operand, int tokenPos) { operand.operandCoding = 612; } -x64Token x64Parser::tokenBranches7368[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7369, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7367[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7366[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367}, {x64Token::EOT}}; -void x64Parser::TokenFunc7382(x64Operand& operand, int tokenPos) { operand.operandCoding = 613; } -x64Token x64Parser::tokenBranches7381[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7382, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7380[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7379[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380}, {x64Token::EOT}}; -void x64Parser::TokenFunc7379(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7365[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7379, x64Parser::tokenBranches7379}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7364[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7363[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7362[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7361[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362}, {x64Token::EOT}}; -void x64Parser::TokenFunc7395(x64Operand& operand, int tokenPos) { operand.operandCoding = 614; } -x64Token x64Parser::tokenBranches7394[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7395, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7393[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7392[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393}, {x64Token::EOT}}; -void x64Parser::TokenFunc7408(x64Operand& operand, int tokenPos) { operand.operandCoding = 615; } -x64Token x64Parser::tokenBranches7407[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7408, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7406[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7405[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406}, {x64Token::EOT}}; -void x64Parser::TokenFunc7405(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7391[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7405, x64Parser::tokenBranches7405}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7390[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7389[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7388[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7387[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7360[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7359[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7358[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359}, {x64Token::EOT}}; -void x64Parser::TokenFunc7417(x64Operand& operand, int tokenPos) { operand.operandCoding = 616; } -x64Token x64Parser::tokenBranches7416[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7417, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7428(x64Operand& operand, int tokenPos) { operand.operandCoding = 617; } -x64Token x64Parser::tokenBranches7427[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7428, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7426[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7425[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426}, {x64Token::EOT}}; -void x64Parser::TokenFunc7425(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7415[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7425, x64Parser::tokenBranches7425}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7414[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7413[] = {{x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7412[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7411[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7410[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7357[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7441(x64Operand& operand, int tokenPos) { operand.operandCoding = 618; } -x64Token x64Parser::tokenBranches7440[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7441, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7439[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7438[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439}, {x64Token::EOT}}; -void x64Parser::TokenFunc7454(x64Operand& operand, int tokenPos) { operand.operandCoding = 619; } -x64Token x64Parser::tokenBranches7453[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7454, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7452[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7451[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452}, {x64Token::EOT}}; -void x64Parser::TokenFunc7451(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7437[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7451, x64Parser::tokenBranches7451}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7436[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7435[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7434[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7433[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434}, {x64Token::EOT}}; -void x64Parser::TokenFunc7467(x64Operand& operand, int tokenPos) { operand.operandCoding = 620; } -x64Token x64Parser::tokenBranches7466[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7467, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7465[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7464[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465}, {x64Token::EOT}}; -void x64Parser::TokenFunc7480(x64Operand& operand, int tokenPos) { operand.operandCoding = 621; } -x64Token x64Parser::tokenBranches7479[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7480, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7478[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7477[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478}, {x64Token::EOT}}; -void x64Parser::TokenFunc7477(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7463[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7477, x64Parser::tokenBranches7477}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7462[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7461[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7460[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7459[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7432[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7431[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7430[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431}, {x64Token::EOT}}; -void x64Parser::TokenFunc7489(x64Operand& operand, int tokenPos) { operand.operandCoding = 622; } -x64Token x64Parser::tokenBranches7488[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7489, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7500(x64Operand& operand, int tokenPos) { operand.operandCoding = 623; } -x64Token x64Parser::tokenBranches7499[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7500, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7498[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7497[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498}, {x64Token::EOT}}; -void x64Parser::TokenFunc7497(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7487[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7497, x64Parser::tokenBranches7497}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7486[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7485[] = {{x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7484[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7483[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7482[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7429[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7513(x64Operand& operand, int tokenPos) { operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7512[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7513, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7511[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7510[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511}, {x64Token::EOT}}; -void x64Parser::TokenFunc7526(x64Operand& operand, int tokenPos) { operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7525[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7526, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7524[] = {{x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7523[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524}, {x64Token::EOT}}; -void x64Parser::TokenFunc7523(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7509[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7523, x64Parser::tokenBranches7523}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7508[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7507[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7506[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7505[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7504[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7503[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7502[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503}, {x64Token::EOT}}; -void x64Parser::TokenFunc7535(x64Operand& operand, int tokenPos) { operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7534[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7535, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7546(x64Operand& operand, int tokenPos) { operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7545[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7544[] = {{x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7543[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544}, {x64Token::EOT}}; -void x64Parser::TokenFunc7543(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7533[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7543, x64Parser::tokenBranches7543}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7532[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7531[] = {{x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7530[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7529[] = {{x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7528[] = {{x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7501[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7284[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7551_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7900[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 685; +} +x64Token x64Parser::tokenBranches7912[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 687; +} +x64Token x64Parser::tokenBranches7922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7551(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7551_16; - operand.values[17] = tokenCoding7551_17; - operand.values[18] = tokenCoding7551_18; - operand.values[19] = tokenCoding7551_19; -} -x64Token x64Parser::tokenBranches7550[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7551, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7549[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7548[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7555_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7899[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7898[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 686; +} +x64Token x64Parser::tokenBranches7916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7917, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7555(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7555_16; - operand.values[17] = tokenCoding7555_17; - operand.values[18] = tokenCoding7555_18; - operand.values[19] = tokenCoding7555_19; -} -x64Token x64Parser::tokenBranches7554[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7555, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7553[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7552[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7559_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7897[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7898, x64Parser::tokenBranches7898 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7890[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 688; +} +x64Token x64Parser::tokenBranches7928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7559(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7559_16; - operand.values[17] = tokenCoding7559_17; - operand.values[18] = tokenCoding7559_18; - operand.values[19] = tokenCoding7559_19; -} -x64Token x64Parser::tokenBranches7558[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7559, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7557[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7556[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7563_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 690; +} +x64Token x64Parser::tokenBranches7940[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7927[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7926[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7563(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7563_16; - operand.values[17] = tokenCoding7563_17; - operand.values[18] = tokenCoding7563_18; - operand.values[19] = tokenCoding7563_19; -} -x64Token x64Parser::tokenBranches7562[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7563, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7561[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7560[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7567_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7925[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 689; +} +x64Token x64Parser::tokenBranches7934[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 691; +} +x64Token x64Parser::tokenBranches7946[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7567(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7567_16; - operand.values[17] = tokenCoding7567_17; - operand.values[18] = tokenCoding7567_18; - operand.values[19] = tokenCoding7567_19; -} -x64Token x64Parser::tokenBranches7566[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7567, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7565[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7564[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7571_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 693; +} +x64Token x64Parser::tokenBranches7956[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7933[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7932[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7571(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7571_16; - operand.values[17] = tokenCoding7571_17; - operand.values[18] = tokenCoding7571_18; - operand.values[19] = tokenCoding7571_19; -} -x64Token x64Parser::tokenBranches7570[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7571, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7569[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7568[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7548(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7552(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7556(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; +void x64Parser::TokenFunc7951(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7547[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc7548, x64Parser::tokenBranches7548}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7552, x64Parser::tokenBranches7552}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7556, x64Parser::tokenBranches7556}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7577_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7950[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7951, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7931[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7932, x64Parser::tokenBranches7932 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7924[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 694; +} +x64Token x64Parser::tokenBranches7962[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7577(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7577_16; - operand.values[17] = tokenCoding7577_17; - operand.values[23] = tokenCoding7577_23; - operand.values[18] = tokenCoding7577_18; - operand.values[19] = tokenCoding7577_19; -} -x64Token x64Parser::tokenBranches7576[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc7577, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7575[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7580_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7961[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7960[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7959[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 695; +} +x64Token x64Parser::tokenBranches7968[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7580(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7580_16; - operand.values[17] = tokenCoding7580_17; - operand.values[23] = tokenCoding7580_23; - operand.values[18] = tokenCoding7580_18; - operand.values[19] = tokenCoding7580_19; -} -x64Token x64Parser::tokenBranches7579[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc7580, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7578[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579}, {x64Token::EOT}}; -void x64Parser::TokenFunc7575(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7581(x64Operand& operand, int tokenPos) { operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7574[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc7575, x64Parser::tokenBranches7575}, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7581, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7583(x64Operand& operand, int tokenPos) { operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches7582[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7583, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7593_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 695; +} +x64Token x64Parser::tokenBranches7978[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7967[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7966[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7593(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7593_16; - operand.values[17] = tokenCoding7593_17; - operand.values[18] = tokenCoding7593_18; - operand.values[19] = tokenCoding7593_19; -} -x64Token x64Parser::tokenBranches7592[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7593, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7589_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7973(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 694; +} +x64Token x64Parser::tokenBranches7972[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7973, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches7965[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7966, x64Parser::tokenBranches7966 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7958[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7589(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7589_16; - operand.values[17] = tokenCoding7589_17; - operand.values[18] = tokenCoding7589_18; - operand.values[19] = tokenCoding7589_19; -} -x64Token x64Parser::tokenBranches7588[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7589, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7587[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588}, {x64Token::EOT}}; -Coding x64Parser::tokenCoding7600_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches7855[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc7984(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 696; +} +x64Token x64Parser::tokenBranches7983[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7984, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_16[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7600(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7600_16; - operand.values[17] = tokenCoding7600_17; - operand.values[18] = tokenCoding7600_18; - operand.values[19] = tokenCoding7600_19; -} -x64Token x64Parser::tokenBranches7599[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7600, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7596_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_17[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_18[] = { + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +Coding x64Parser::tokenCoding8024_19[] = { + { CODING_NAME("reg") Coding::stateFunc, 4 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7596(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7596_16; - operand.values[17] = tokenCoding7596_17; - operand.values[18] = tokenCoding7596_18; - operand.values[19] = tokenCoding7596_19; -} -x64Token x64Parser::tokenBranches7595[] = {{ - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7596, - }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7594[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595}, {x64Token::EOT}}; -void x64Parser::TokenFunc7587(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7594(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7586[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc7587, x64Parser::tokenBranches7587}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc7594, x64Parser::tokenBranches7594}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7610(x64Operand& operand, int tokenPos) { operand.operandCoding = 628; } -x64Token x64Parser::tokenBranches7609[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7610, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7608[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609}, {x64Token::EOT}}; -void x64Parser::TokenFunc7608(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7607[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7608, x64Parser::tokenBranches7608}, {x64Token::EOT}}; -void x64Parser::TokenFunc7614(x64Operand& operand, int tokenPos) { operand.operandCoding = 629; } -x64Token x64Parser::tokenBranches7613[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7614, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7612[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613}, {x64Token::EOT}}; -void x64Parser::TokenFunc7612(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7611[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7612, x64Parser::tokenBranches7612}, {x64Token::EOT}}; -void x64Parser::TokenFunc7618(x64Operand& operand, int tokenPos) { operand.operandCoding = 630; } -x64Token x64Parser::tokenBranches7617[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7618, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7616[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617}, {x64Token::EOT}}; -void x64Parser::TokenFunc7616(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7615[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7616, x64Parser::tokenBranches7616}, {x64Token::EOT}}; -void x64Parser::TokenFunc7622(x64Operand& operand, int tokenPos) { operand.operandCoding = 631; } -x64Token x64Parser::tokenBranches7621[] = {{ - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7622, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7620[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621}, {x64Token::EOT}}; -void x64Parser::TokenFunc7620(x64Operand& operand, int tokenPos) -{ - operand.values[29] = new Coding[2]; - CleanupValues.push_back(operand.values[29]); - operand.values[29]->type = Coding::number; - operand.values[29]->val = operands.size(); - operand.values[29]->bits = 0; - operand.values[29]->field = 0; - operand.values[29]->unary = 0; - operand.values[29]->binary = 0; - operand.values[29][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7619[] = { - {x64Token::NUMBER, 3, 0, 0, NULL, &x64Parser::TokenFunc7620, x64Parser::tokenBranches7620}, {x64Token::EOT}}; -void x64Parser::TokenFunc7625(x64Operand& operand, int tokenPos) { operand.operandCoding = 632; } -void x64Parser::TokenFunc7628(x64Operand& operand, int tokenPos) { operand.operandCoding = 633; } -void x64Parser::TokenFunc7631(x64Operand& operand, int tokenPos) { operand.operandCoding = 634; } -void x64Parser::TokenFunc7634(x64Operand& operand, int tokenPos) { operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches7624[] = {{ - x64Token::REGISTER, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7625, - }, - { - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7628, - }, - { - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc7631, - }, - { - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7634, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7623[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7606[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619}, - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7643(x64Operand& operand, int tokenPos) { operand.operandCoding = 636; } -x64Token x64Parser::tokenBranches7642[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7643, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7659(x64Operand& operand, int tokenPos) { operand.operandCoding = 638; } -x64Token x64Parser::tokenBranches7658[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7659, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7641[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7640[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641}, {x64Token::EOT}}; -void x64Parser::TokenFunc7651(x64Operand& operand, int tokenPos) { operand.operandCoding = 637; } -x64Token x64Parser::tokenBranches7650[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7651, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7667(x64Operand& operand, int tokenPos) { operand.operandCoding = 639; } -x64Token x64Parser::tokenBranches7666[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7667, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7681(x64Operand& operand, int tokenPos) { operand.operandCoding = 641; } -x64Token x64Parser::tokenBranches7680[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7681, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7649[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7648[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649}, {x64Token::EOT}}; -void x64Parser::TokenFunc7673(x64Operand& operand, int tokenPos) { operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches7672[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7673, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7648(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc8024(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8024_16; + operand.values[17] = tokenCoding8024_17; + operand.values[18] = tokenCoding8024_18; + operand.values[19] = tokenCoding8024_19; } -x64Token x64Parser::tokenBranches7639[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7648, x64Parser::tokenBranches7648}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7638[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639}, {x64Token::EOT}}; -void x64Parser::TokenFunc7689(x64Operand& operand, int tokenPos) { operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7688[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7689, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7705(x64Operand& operand, int tokenPos) { operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7704[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7705, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7687[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7686[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687}, {x64Token::EOT}}; -void x64Parser::TokenFunc7697(x64Operand& operand, int tokenPos) { operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7696[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7697, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7713(x64Operand& operand, int tokenPos) { operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7712[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7713, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7727(x64Operand& operand, int tokenPos) { operand.operandCoding = 647; } -x64Token x64Parser::tokenBranches7726[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7727, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7695[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7694[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695}, {x64Token::EOT}}; -void x64Parser::TokenFunc7719(x64Operand& operand, int tokenPos) { operand.operandCoding = 646; } -x64Token x64Parser::tokenBranches7718[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7719, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7694(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8023[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8024, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8034(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches7685[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7694, x64Parser::tokenBranches7694}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7684[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685}, {x64Token::EOT}}; -void x64Parser::TokenFunc7735(x64Operand& operand, int tokenPos) { operand.operandCoding = 648; } -x64Token x64Parser::tokenBranches7734[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7735, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7751(x64Operand& operand, int tokenPos) { operand.operandCoding = 650; } -x64Token x64Parser::tokenBranches7750[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7751, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7733[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7732[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733}, {x64Token::EOT}}; -void x64Parser::TokenFunc7743(x64Operand& operand, int tokenPos) { operand.operandCoding = 649; } -x64Token x64Parser::tokenBranches7742[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7743, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7759(x64Operand& operand, int tokenPos) { operand.operandCoding = 651; } -x64Token x64Parser::tokenBranches7758[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7759, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7773(x64Operand& operand, int tokenPos) { operand.operandCoding = 653; } -x64Token x64Parser::tokenBranches7772[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7773, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7741[] = {{x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742}, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7740[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741}, {x64Token::EOT}}; -void x64Parser::TokenFunc7765(x64Operand& operand, int tokenPos) { operand.operandCoding = 652; } -x64Token x64Parser::tokenBranches7764[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7765, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7740(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8033[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8034, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches7731[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7740, x64Parser::tokenBranches7740}, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7730[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7637[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7636[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7635[] = {{x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636}, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7782_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8032[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8031[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7782(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7782_16; - operand.values[17] = tokenCoding7782_17; - operand.values[18] = tokenCoding7782_18; - operand.values[19] = tokenCoding7782_19; -} -x64Token x64Parser::tokenBranches7781[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7782, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7784_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8030[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 698; +} +x64Token x64Parser::tokenBranches8039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 700; +} +x64Token x64Parser::tokenBranches8051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7784(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7784_16; - operand.values[17] = tokenCoding7784_17; - operand.values[18] = tokenCoding7784_18; - operand.values[19] = tokenCoding7784_19; -} -x64Token x64Parser::tokenBranches7783[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7784, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7786_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 702; +} +x64Token x64Parser::tokenBranches8061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8038[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8037[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7786(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding7786_16; - operand.values[17] = tokenCoding7786_17; - operand.values[18] = tokenCoding7786_18; - operand.values[19] = tokenCoding7786_19; -} -x64Token x64Parser::tokenBranches7785[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7786, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7778(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 654; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7779(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 655; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7780(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 656; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7787(x64Operand& operand, int tokenPos) { operand.operandCoding = 657; } -void x64Parser::TokenFunc7788(x64Operand& operand, int tokenPos) { operand.operandCoding = 658; } -void x64Parser::TokenFunc7789(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 659; - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7777[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7778, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7779, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7780, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785}, - { - x64Token::REGISTER, - 97, - 1, - 0, - NULL, - &x64Parser::TokenFunc7787, - }, - { - x64Token::REGISTER, - 98, - 1, - 0, - NULL, - &x64Parser::TokenFunc7788, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7789, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7799_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8056(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 701; +} +x64Token x64Parser::tokenBranches8055[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8056, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8036[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8037, x64Parser::tokenBranches8037 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8029[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 703; +} +x64Token x64Parser::tokenBranches8067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 705; +} +x64Token x64Parser::tokenBranches8079[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7799(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7799_34; - operand.values[16] = tokenCoding7799_16; - operand.values[17] = tokenCoding7799_17; - operand.values[35] = tokenCoding7799_35; - operand.values[18] = tokenCoding7799_18; - operand.values[19] = tokenCoding7799_19; -} -x64Token x64Parser::tokenBranches7798[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7799, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7801_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8066[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8065[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8064[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 704; +} +x64Token x64Parser::tokenBranches8073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 706; +} +x64Token x64Parser::tokenBranches8085[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7801(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7801_34; - operand.values[16] = tokenCoding7801_16; - operand.values[17] = tokenCoding7801_17; - operand.values[35] = tokenCoding7801_35; - operand.values[18] = tokenCoding7801_18; - operand.values[19] = tokenCoding7801_19; -} -x64Token x64Parser::tokenBranches7800[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7801, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7803_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 708; +} +x64Token x64Parser::tokenBranches8095[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8072[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8071[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8090(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 707; +} +x64Token x64Parser::tokenBranches8089[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8090, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8070[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8071, x64Parser::tokenBranches8071 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7803(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7803_34; - operand.values[16] = tokenCoding7803_16; - operand.values[17] = tokenCoding7803_17; - operand.values[35] = tokenCoding7803_35; - operand.values[18] = tokenCoding7803_18; - operand.values[19] = tokenCoding7803_19; -} -x64Token x64Parser::tokenBranches7802[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7803, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding7805_34[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8063[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 709; +} +x64Token x64Parser::tokenBranches8101[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 711; +} +x64Token x64Parser::tokenBranches8113[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_35[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8100[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8099[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7805(x64Operand& operand, int tokenPos) -{ - operand.values[34] = tokenCoding7805_34; - operand.values[16] = tokenCoding7805_16; - operand.values[17] = tokenCoding7805_17; - operand.values[35] = tokenCoding7805_35; - operand.values[18] = tokenCoding7805_18; - operand.values[19] = tokenCoding7805_19; -} -x64Token x64Parser::tokenBranches7804[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7805, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7811(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 663; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches7810[] = {{ - x64Token::NUMBER, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7811, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7816(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 664; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +x64Token x64Parser::tokenBranches8098[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 710; } -Coding x64Parser::tokenCoding7822_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 712; +} +x64Token x64Parser::tokenBranches8119[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 714; +} +x64Token x64Parser::tokenBranches8129[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8105[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7822_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7822(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 667; - operand.values[16] = tokenCoding7822_16; - operand.values[17] = tokenCoding7822_17; - operand.values[18] = tokenCoding7822_18; - operand.values[19] = tokenCoding7822_19; -} -x64Token x64Parser::tokenBranches7815[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7816, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7822, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7818(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 665; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc8124(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 713; } -Coding x64Parser::tokenCoding7824_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8123[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8124, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8104[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8105, x64Parser::tokenBranches8105 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8097[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7824_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7824(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 668; - operand.values[16] = tokenCoding7824_16; - operand.values[17] = tokenCoding7824_17; - operand.values[18] = tokenCoding7824_18; - operand.values[19] = tokenCoding7824_19; -} -x64Token x64Parser::tokenBranches7817[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7818, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7824, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7820(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 666; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); +void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 715; } -Coding x64Parser::tokenCoding7826_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8135[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8134[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8133[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding7826_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc7826(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 668; - operand.values[16] = tokenCoding7826_16; - operand.values[17] = tokenCoding7826_17; - operand.values[18] = tokenCoding7826_18; - operand.values[19] = tokenCoding7826_19; -} -x64Token x64Parser::tokenBranches7819[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc7820, - }, - { - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc7826, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7807(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 660; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7808(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 661; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7809(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 662; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc7812(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 664; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7813(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 665; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7814(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 666; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7827(x64Operand& operand, int tokenPos) { operand.operandCoding = 669; } -void x64Parser::TokenFunc7828(x64Operand& operand, int tokenPos) { operand.operandCoding = 670; } -void x64Parser::TokenFunc7829(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 671; - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7806[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7807, - }, - { - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7808, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc7809, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810}, - { - x64Token::NUMBER, - 6, - 1, - 0, - NULL, - &x64Parser::TokenFunc7812, - }, - { - x64Token::NUMBER, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc7813, - }, - { - x64Token::NUMBER, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc7814, - }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819}, - { - x64Token::REGISTER, - 97, - 1, - 0, - NULL, - &x64Parser::TokenFunc7827, - }, - { - x64Token::REGISTER, - 98, - 1, - 0, - NULL, - &x64Parser::TokenFunc7828, - }, - { - x64Token::REGISTERCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc7829, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7843(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 672; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7844(x64Operand& operand, int tokenPos) { operand.operandCoding = 673; } -x64Token x64Parser::tokenBranches7842[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7843, - }, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7844, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7846(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 674; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7847(x64Operand& operand, int tokenPos) { operand.operandCoding = 675; } -x64Token x64Parser::tokenBranches7845[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc7846, - }, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7847, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7861(x64Operand& operand, int tokenPos) { operand.operandCoding = 676; } -x64Token x64Parser::tokenBranches7860[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7861, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7873(x64Operand& operand, int tokenPos) { operand.operandCoding = 678; } -x64Token x64Parser::tokenBranches7872[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7873, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7859[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7858[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7857[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858}, {x64Token::EOT}}; -void x64Parser::TokenFunc7867(x64Operand& operand, int tokenPos) { operand.operandCoding = 677; } -x64Token x64Parser::tokenBranches7866[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7867, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7879(x64Operand& operand, int tokenPos) { operand.operandCoding = 679; } -x64Token x64Parser::tokenBranches7878[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7879, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7889(x64Operand& operand, int tokenPos) { operand.operandCoding = 681; } -x64Token x64Parser::tokenBranches7888[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7889, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7865[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7864[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865}, {x64Token::EOT}}; -void x64Parser::TokenFunc7883(x64Operand& operand, int tokenPos) { operand.operandCoding = 680; } -x64Token x64Parser::tokenBranches7882[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7883, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7864(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7863[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7864, x64Parser::tokenBranches7864}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7856[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7895(x64Operand& operand, int tokenPos) { operand.operandCoding = 682; } -x64Token x64Parser::tokenBranches7894[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7895, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7907(x64Operand& operand, int tokenPos) { operand.operandCoding = 684; } -x64Token x64Parser::tokenBranches7906[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7907, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7893[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7892[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7891[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892}, {x64Token::EOT}}; -void x64Parser::TokenFunc7901(x64Operand& operand, int tokenPos) { operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7900[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7901, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7913(x64Operand& operand, int tokenPos) { operand.operandCoding = 685; } -x64Token x64Parser::tokenBranches7912[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7913, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7923(x64Operand& operand, int tokenPos) { operand.operandCoding = 687; } -x64Token x64Parser::tokenBranches7922[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7923, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7899[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7898[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899}, {x64Token::EOT}}; -void x64Parser::TokenFunc7917(x64Operand& operand, int tokenPos) { operand.operandCoding = 686; } -x64Token x64Parser::tokenBranches7916[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7917, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7898(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches7897[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7898, x64Parser::tokenBranches7898}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7890[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7929(x64Operand& operand, int tokenPos) { operand.operandCoding = 688; } -x64Token x64Parser::tokenBranches7928[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7929, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7941(x64Operand& operand, int tokenPos) { operand.operandCoding = 690; } -x64Token x64Parser::tokenBranches7940[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7941, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7927[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7926[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7925[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926}, {x64Token::EOT}}; -void x64Parser::TokenFunc7935(x64Operand& operand, int tokenPos) { operand.operandCoding = 689; } -x64Token x64Parser::tokenBranches7934[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7935, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7947(x64Operand& operand, int tokenPos) { operand.operandCoding = 691; } -x64Token x64Parser::tokenBranches7946[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7947, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7957(x64Operand& operand, int tokenPos) { operand.operandCoding = 693; } -x64Token x64Parser::tokenBranches7956[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7957, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7933[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7932[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933}, {x64Token::EOT}}; -void x64Parser::TokenFunc7951(x64Operand& operand, int tokenPos) { operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7950[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7951, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7932(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8132[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches7931[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7932, x64Parser::tokenBranches7932}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7924[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7963(x64Operand& operand, int tokenPos) { operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7962[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7963, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7961[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7960[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7959[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960}, {x64Token::EOT}}; -void x64Parser::TokenFunc7969(x64Operand& operand, int tokenPos) { operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7968[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7969, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7979(x64Operand& operand, int tokenPos) { operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7978[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7979, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7967[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7966[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967}, {x64Token::EOT}}; -void x64Parser::TokenFunc7973(x64Operand& operand, int tokenPos) { operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7972[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc7973, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc7966(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8141[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches7965[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc7966, x64Parser::tokenBranches7966}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7958[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches7855[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958}, - {x64Token::EOT}}; -void x64Parser::TokenFunc7984(x64Operand& operand, int tokenPos) { operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7983[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc7984, - }, - {x64Token::EOT}}; -Coding x64Parser::tokenCoding8024_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8151[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8140[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, +x64Token x64Parser::tokenBranches8139[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, + {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 4}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8024(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8024_16; - operand.values[17] = tokenCoding8024_17; - operand.values[18] = tokenCoding8024_18; - operand.values[19] = tokenCoding8024_19; -} -x64Token x64Parser::tokenBranches8023[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8024, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8034(x64Operand& operand, int tokenPos) { operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches8033[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8034, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8046(x64Operand& operand, int tokenPos) { operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches8045[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8046, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8032[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8031[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8030[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031}, {x64Token::EOT}}; -void x64Parser::TokenFunc8040(x64Operand& operand, int tokenPos) { operand.operandCoding = 698; } -x64Token x64Parser::tokenBranches8039[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8040, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8052(x64Operand& operand, int tokenPos) { operand.operandCoding = 700; } -x64Token x64Parser::tokenBranches8051[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8052, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8062(x64Operand& operand, int tokenPos) { operand.operandCoding = 702; } -x64Token x64Parser::tokenBranches8061[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8062, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8038[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8037[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038}, {x64Token::EOT}}; -void x64Parser::TokenFunc8056(x64Operand& operand, int tokenPos) { operand.operandCoding = 701; } -x64Token x64Parser::tokenBranches8055[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8056, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8037(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8036[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8037, x64Parser::tokenBranches8037}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8029[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8068(x64Operand& operand, int tokenPos) { operand.operandCoding = 703; } -x64Token x64Parser::tokenBranches8067[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8068, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8080(x64Operand& operand, int tokenPos) { operand.operandCoding = 705; } -x64Token x64Parser::tokenBranches8079[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8080, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8066[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8065[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8064[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065}, {x64Token::EOT}}; -void x64Parser::TokenFunc8074(x64Operand& operand, int tokenPos) { operand.operandCoding = 704; } -x64Token x64Parser::tokenBranches8073[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8074, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8086(x64Operand& operand, int tokenPos) { operand.operandCoding = 706; } -x64Token x64Parser::tokenBranches8085[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8086, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8096(x64Operand& operand, int tokenPos) { operand.operandCoding = 708; } -x64Token x64Parser::tokenBranches8095[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8096, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8072[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8071[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072}, {x64Token::EOT}}; -void x64Parser::TokenFunc8090(x64Operand& operand, int tokenPos) { operand.operandCoding = 707; } -x64Token x64Parser::tokenBranches8089[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8090, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8071(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8070[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8071, x64Parser::tokenBranches8071}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8063[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8102(x64Operand& operand, int tokenPos) { operand.operandCoding = 709; } -x64Token x64Parser::tokenBranches8101[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8102, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8114(x64Operand& operand, int tokenPos) { operand.operandCoding = 711; } -x64Token x64Parser::tokenBranches8113[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8114, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8100[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8099[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8098[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099}, {x64Token::EOT}}; -void x64Parser::TokenFunc8108(x64Operand& operand, int tokenPos) { operand.operandCoding = 710; } -x64Token x64Parser::tokenBranches8107[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8108, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8120(x64Operand& operand, int tokenPos) { operand.operandCoding = 712; } -x64Token x64Parser::tokenBranches8119[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8120, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8130(x64Operand& operand, int tokenPos) { operand.operandCoding = 714; } -x64Token x64Parser::tokenBranches8129[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8130, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8106[] = {{x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107}, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8105[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106}, {x64Token::EOT}}; -void x64Parser::TokenFunc8124(x64Operand& operand, int tokenPos) { operand.operandCoding = 713; } -x64Token x64Parser::tokenBranches8123[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8124, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8105(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +void x64Parser::TokenFunc8146(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8104[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8105, x64Parser::tokenBranches8105}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8097[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8136(x64Operand& operand, int tokenPos) { operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8135[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8136, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8134[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8133[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8132[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133}, {x64Token::EOT}}; -void x64Parser::TokenFunc8142(x64Operand& operand, int tokenPos) { operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8141[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8142, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8152(x64Operand& operand, int tokenPos) { operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8151[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8152, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8140[] = {{x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8139[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140}, {x64Token::EOT}}; -void x64Parser::TokenFunc8146(x64Operand& operand, int tokenPos) { operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8145[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8146, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8139(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; +x64Token x64Parser::tokenBranches8145[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8146, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8138[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8139, x64Parser::tokenBranches8139}, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8131[] = {{x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132}, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8028[] = {{x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8157(x64Operand& operand, int tokenPos) { operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8156[] = {{ - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc8157, - }, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8139, x64Parser::tokenBranches8139 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8131[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8028[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8157(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 717; +} +x64Token x64Parser::tokenBranches8156[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8157, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8159_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8159_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 4}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") Coding::stateFunc, 4 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8159(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8159(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8159_16; - operand.values[17] = tokenCoding8159_17; - operand.values[18] = tokenCoding8159_18; - operand.values[19] = tokenCoding8159_19; + operand.values[16] = tokenCoding8159_16; + operand.values[17] = tokenCoding8159_17; + operand.values[18] = tokenCoding8159_18; + operand.values[19] = tokenCoding8159_19; } Coding x64Parser::tokenCoding8160_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8160_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 5}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") Coding::stateFunc, 5 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8160(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8160(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8160_16; - operand.values[17] = tokenCoding8160_17; - operand.values[18] = tokenCoding8160_18; - operand.values[19] = tokenCoding8160_19; + operand.values[16] = tokenCoding8160_16; + operand.values[17] = tokenCoding8160_17; + operand.values[18] = tokenCoding8160_18; + operand.values[19] = tokenCoding8160_19; } Coding x64Parser::tokenCoding8161_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8161_19[] = { - {CODING_NAME("reg") Coding::stateFunc, 6}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8161(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8161_16; - operand.values[17] = tokenCoding8161_17; - operand.values[18] = tokenCoding8161_18; - operand.values[19] = tokenCoding8161_19; -} -x64Token x64Parser::tokenBranches8158[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8159, - }, - { - x64Token::ADDRESSCLASS, - 19, - 1, - 0, - NULL, - &x64Parser::TokenFunc8160, - }, - { - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc8161, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8171(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 718; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8170[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8171, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8169[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8168[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169}, {x64Token::EOT}}; -void x64Parser::TokenFunc8175(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 719; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8174[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8175, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8173[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8172[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173}, {x64Token::EOT}}; -void x64Parser::TokenFunc8179(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 720; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8178[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8179, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8177[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8176[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177}, {x64Token::EOT}}; -void x64Parser::TokenFunc8183(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 721; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -x64Token x64Parser::tokenBranches8182[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8183, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8181[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8180[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181}, {x64Token::EOT}}; + { CODING_NAME("reg") Coding::stateFunc, 6 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8161(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8161_16; + operand.values[17] = tokenCoding8161_17; + operand.values[18] = tokenCoding8161_18; + operand.values[19] = tokenCoding8161_19; +} +x64Token x64Parser::tokenBranches8158[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8159, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8160, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8161, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 718; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8170[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8171, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8169[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8168[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 719; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8174[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8175, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8173[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8172[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 720; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8178[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8179, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8177[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8176[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 721; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches8182[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8183, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8181[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8180[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8187_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8187_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8187(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8187_16; - operand.values[17] = tokenCoding8187_17; - operand.values[18] = tokenCoding8187_18; - operand.values[19] = tokenCoding8187_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8187_16; + operand.values[17] = tokenCoding8187_17; + operand.values[18] = tokenCoding8187_18; + operand.values[19] = tokenCoding8187_19; } Coding x64Parser::tokenCoding8191_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8191_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8191(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8191_16; - operand.values[17] = tokenCoding8191_17; - operand.values[23] = tokenCoding8191_23; - operand.values[18] = tokenCoding8191_18; - operand.values[19] = tokenCoding8191_19; -} -x64Token x64Parser::tokenBranches8186[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8187, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8191, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8185[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8184[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8191_16; + operand.values[17] = tokenCoding8191_17; + operand.values[23] = tokenCoding8191_23; + operand.values[18] = tokenCoding8191_18; + operand.values[19] = tokenCoding8191_19; +} +x64Token x64Parser::tokenBranches8186[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8187, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8191, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8185[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8184[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8195_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8195_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8195(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8195_16; - operand.values[17] = tokenCoding8195_17; - operand.values[18] = tokenCoding8195_18; - operand.values[19] = tokenCoding8195_19; -} -x64Token x64Parser::tokenBranches8194[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8195, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8193[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8192[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8195_16; + operand.values[17] = tokenCoding8195_17; + operand.values[18] = tokenCoding8195_18; + operand.values[19] = tokenCoding8195_19; +} +x64Token x64Parser::tokenBranches8194[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8195, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8193[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8192[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8199_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8199_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8199(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8199_16; - operand.values[17] = tokenCoding8199_17; - operand.values[18] = tokenCoding8199_18; - operand.values[19] = tokenCoding8199_19; -} -x64Token x64Parser::tokenBranches8198[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8199, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8197[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8196[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8199_16; + operand.values[17] = tokenCoding8199_17; + operand.values[18] = tokenCoding8199_18; + operand.values[19] = tokenCoding8199_19; +} +x64Token x64Parser::tokenBranches8198[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8199, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8196[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8203_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8203_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8203(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8203_16; - operand.values[17] = tokenCoding8203_17; - operand.values[18] = tokenCoding8203_18; - operand.values[19] = tokenCoding8203_19; -} -x64Token x64Parser::tokenBranches8202[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8203, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8201[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8200[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8203_16; + operand.values[17] = tokenCoding8203_17; + operand.values[18] = tokenCoding8203_18; + operand.values[19] = tokenCoding8203_19; +} +x64Token x64Parser::tokenBranches8202[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8203, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8201[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8200[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8248_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8248_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8248(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8248_16; - operand.values[17] = tokenCoding8248_17; - operand.values[18] = tokenCoding8248_18; - operand.values[19] = tokenCoding8248_19; -} -x64Token x64Parser::tokenBranches8247[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8248, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8248_16; + operand.values[17] = tokenCoding8248_17; + operand.values[18] = tokenCoding8248_18; + operand.values[19] = tokenCoding8248_19; +} +x64Token x64Parser::tokenBranches8247[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8248, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8206_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8206_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8206(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8206_16; - operand.values[17] = tokenCoding8206_17; - operand.values[18] = tokenCoding8206_18; - operand.values[19] = tokenCoding8206_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8206_16; + operand.values[17] = tokenCoding8206_17; + operand.values[18] = tokenCoding8206_18; + operand.values[19] = tokenCoding8206_19; } Coding x64Parser::tokenCoding8212_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8212_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8212(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8212_16; - operand.values[17] = tokenCoding8212_17; - operand.values[23] = tokenCoding8212_23; - operand.values[18] = tokenCoding8212_18; - operand.values[19] = tokenCoding8212_19; -} -x64Token x64Parser::tokenBranches8205[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8206, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8212, - }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8204[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8212_16; + operand.values[17] = tokenCoding8212_17; + operand.values[23] = tokenCoding8212_23; + operand.values[18] = tokenCoding8212_18; + operand.values[19] = tokenCoding8212_19; +} +x64Token x64Parser::tokenBranches8205[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8206, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8212, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8204[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8209_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8209_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8209(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8209_16; - operand.values[17] = tokenCoding8209_17; - operand.values[23] = tokenCoding8209_23; - operand.values[18] = tokenCoding8209_18; - operand.values[19] = tokenCoding8209_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8209_16; + operand.values[17] = tokenCoding8209_17; + operand.values[23] = tokenCoding8209_23; + operand.values[18] = tokenCoding8209_18; + operand.values[19] = tokenCoding8209_19; } Coding x64Parser::tokenCoding8215_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8215_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8215(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8215_16; - operand.values[17] = tokenCoding8215_17; - operand.values[23] = tokenCoding8215_23; - operand.values[18] = tokenCoding8215_18; - operand.values[19] = tokenCoding8215_19; -} -x64Token x64Parser::tokenBranches8208[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8209, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8215, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8207[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8215_16; + operand.values[17] = tokenCoding8215_17; + operand.values[23] = tokenCoding8215_23; + operand.values[18] = tokenCoding8215_18; + operand.values[19] = tokenCoding8215_19; +} +x64Token x64Parser::tokenBranches8208[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8209, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8215, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8207[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8252_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8252_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8252(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8252_16; - operand.values[17] = tokenCoding8252_17; - operand.values[18] = tokenCoding8252_18; - operand.values[19] = tokenCoding8252_19; -} -x64Token x64Parser::tokenBranches8251[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8252, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8252_16; + operand.values[17] = tokenCoding8252_17; + operand.values[18] = tokenCoding8252_18; + operand.values[19] = tokenCoding8252_19; +} +x64Token x64Parser::tokenBranches8251[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8252, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8218_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8218_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8218(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8218_16; - operand.values[17] = tokenCoding8218_17; - operand.values[18] = tokenCoding8218_18; - operand.values[19] = tokenCoding8218_19; -} -x64Token x64Parser::tokenBranches8217[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8218, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8216[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8218_16; + operand.values[17] = tokenCoding8218_17; + operand.values[18] = tokenCoding8218_18; + operand.values[19] = tokenCoding8218_19; +} +x64Token x64Parser::tokenBranches8217[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8218, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8216[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8256_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8256_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8256(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8256_16; - operand.values[17] = tokenCoding8256_17; - operand.values[18] = tokenCoding8256_18; - operand.values[19] = tokenCoding8256_19; -} -x64Token x64Parser::tokenBranches8255[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8256, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8256_16; + operand.values[17] = tokenCoding8256_17; + operand.values[18] = tokenCoding8256_18; + operand.values[19] = tokenCoding8256_19; +} +x64Token x64Parser::tokenBranches8255[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8256, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8221_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8221_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8221(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8221_16; - operand.values[17] = tokenCoding8221_17; - operand.values[18] = tokenCoding8221_18; - operand.values[19] = tokenCoding8221_19; -} -x64Token x64Parser::tokenBranches8220[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8221, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8219[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8221_16; + operand.values[17] = tokenCoding8221_17; + operand.values[18] = tokenCoding8221_18; + operand.values[19] = tokenCoding8221_19; +} +x64Token x64Parser::tokenBranches8220[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8221, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8219[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8260_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8260_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8260(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8260_16; - operand.values[17] = tokenCoding8260_17; - operand.values[18] = tokenCoding8260_18; - operand.values[19] = tokenCoding8260_19; -} -x64Token x64Parser::tokenBranches8259[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8260, - }, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8260_16; + operand.values[17] = tokenCoding8260_17; + operand.values[18] = tokenCoding8260_18; + operand.values[19] = tokenCoding8260_19; +} +x64Token x64Parser::tokenBranches8259[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8260, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8224_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8224_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8224(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8224_16; - operand.values[17] = tokenCoding8224_17; - operand.values[18] = tokenCoding8224_18; - operand.values[19] = tokenCoding8224_19; -} -x64Token x64Parser::tokenBranches8223[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8224, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8222[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8224_16; + operand.values[17] = tokenCoding8224_17; + operand.values[18] = tokenCoding8224_18; + operand.values[19] = tokenCoding8224_19; +} +x64Token x64Parser::tokenBranches8223[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8224, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8222[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8228_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8228_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8228(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8228_16; - operand.values[17] = tokenCoding8228_17; - operand.values[18] = tokenCoding8228_18; - operand.values[19] = tokenCoding8228_19; -} -x64Token x64Parser::tokenBranches8227[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8228, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8226[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8225[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8228(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8228_16; + operand.values[17] = tokenCoding8228_17; + operand.values[18] = tokenCoding8228_18; + operand.values[19] = tokenCoding8228_19; +} +x64Token x64Parser::tokenBranches8227[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8228, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8226[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8232_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8232_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8232(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8232_16; - operand.values[17] = tokenCoding8232_17; - operand.values[23] = tokenCoding8232_23; - operand.values[18] = tokenCoding8232_18; - operand.values[19] = tokenCoding8232_19; -} -x64Token x64Parser::tokenBranches8231[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8232, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8230[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8229[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8232(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8232_16; + operand.values[17] = tokenCoding8232_17; + operand.values[23] = tokenCoding8232_23; + operand.values[18] = tokenCoding8232_18; + operand.values[19] = tokenCoding8232_19; +} +x64Token x64Parser::tokenBranches8231[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8232, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8230[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8236_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8236_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8236(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8236_16; - operand.values[17] = tokenCoding8236_17; - operand.values[18] = tokenCoding8236_18; - operand.values[19] = tokenCoding8236_19; -} -x64Token x64Parser::tokenBranches8235[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8236, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8234[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8233[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8236(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8236_16; + operand.values[17] = tokenCoding8236_17; + operand.values[18] = tokenCoding8236_18; + operand.values[19] = tokenCoding8236_19; +} +x64Token x64Parser::tokenBranches8235[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8236, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8234[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8233[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8240_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8240_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8240(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8240_16; - operand.values[17] = tokenCoding8240_17; - operand.values[18] = tokenCoding8240_18; - operand.values[19] = tokenCoding8240_19; -} -x64Token x64Parser::tokenBranches8239[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8240, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8238[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8237[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8240(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8240_16; + operand.values[17] = tokenCoding8240_17; + operand.values[18] = tokenCoding8240_18; + operand.values[19] = tokenCoding8240_19; +} +x64Token x64Parser::tokenBranches8239[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8240, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8238[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8244_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8244_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8244(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8244_16; - operand.values[17] = tokenCoding8244_17; - operand.values[18] = tokenCoding8244_18; - operand.values[19] = tokenCoding8244_19; -} -x64Token x64Parser::tokenBranches8243[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8244, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8242[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8241[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8244(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8244_16; + operand.values[17] = tokenCoding8244_17; + operand.values[18] = tokenCoding8244_18; + operand.values[19] = tokenCoding8244_19; +} +x64Token x64Parser::tokenBranches8243[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8244, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8242[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8241[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8265_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8265_19[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8265(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 449; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8265_16; - operand.values[17] = tokenCoding8265_17; - operand.values[18] = tokenCoding8265_18; - operand.values[19] = tokenCoding8265_19; -} -x64Token x64Parser::tokenBranches8264[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8265, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8263[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8262[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8261[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262}, - {x64Token::EOT}}; + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 449; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8265_16; + operand.values[17] = tokenCoding8265_17; + operand.values[18] = tokenCoding8265_18; + operand.values[19] = tokenCoding8265_19; +} +x64Token x64Parser::tokenBranches8264[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8265, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8263[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8262[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8261[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8270_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8270_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 4}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8270(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 512; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8270_16; - operand.values[17] = tokenCoding8270_17; - operand.values[18] = tokenCoding8270_18; - operand.values[19] = tokenCoding8270_19; -} -x64Token x64Parser::tokenBranches8269[] = {{ - x64Token::NUMBER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8270, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8268[] = {{x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8267[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8266[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267}, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 4 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 512; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8270_16; + operand.values[17] = tokenCoding8270_17; + operand.values[18] = tokenCoding8270_18; + operand.values[19] = tokenCoding8270_19; +} +x64Token x64Parser::tokenBranches8269[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8270, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8268[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8267[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8266[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8275_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8275_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 5}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8275(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8275_16; - operand.values[17] = tokenCoding8275_17; - operand.values[18] = tokenCoding8275_18; - operand.values[19] = tokenCoding8275_19; -} -x64Token x64Parser::tokenBranches8274[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8275, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8273[] = {{x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8272[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8271[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272}, - {x64Token::EOT}}; + { CODING_NAME("omem") Coding::stateFunc, 5 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8275_16; + operand.values[17] = tokenCoding8275_17; + operand.values[18] = tokenCoding8275_18; + operand.values[19] = tokenCoding8275_19; +} +x64Token x64Parser::tokenBranches8274[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8275, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8273[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8272[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8271[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8280_16[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_17[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_18[] = { - {CODING_NAME("omem")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8280_19[] = { - {CODING_NAME("omem") Coding::stateFunc, 6}, - {CODING_NAME("omem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8280(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 513; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8280_16; - operand.values[17] = tokenCoding8280_17; - operand.values[18] = tokenCoding8280_18; - operand.values[19] = tokenCoding8280_19; -} -x64Token x64Parser::tokenBranches8279[] = {{ - x64Token::NUMBER, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8280, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8278[] = {{x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8277[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8276[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8225(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8229(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8233(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8237(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8241(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("omem") Coding::stateFunc, 6 }, + { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 513; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8280_16; + operand.values[17] = tokenCoding8280_17; + operand.values[18] = tokenCoding8280_18; + operand.values[19] = tokenCoding8280_19; +} +x64Token x64Parser::tokenBranches8279[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8280, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8278[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8277[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8276[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8167[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168}, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200}, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204}, - {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207}, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216}, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc8225, x64Parser::tokenBranches8225}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc8229, x64Parser::tokenBranches8229}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc8233, x64Parser::tokenBranches8233}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8237, x64Parser::tokenBranches8237}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8241, x64Parser::tokenBranches8241}, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261}, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266}, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271}, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276}, - {x64Token::EOT}}; + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, + {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8225, x64Parser::tokenBranches8225 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8229, x64Parser::tokenBranches8229 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8233, x64Parser::tokenBranches8233 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8237, x64Parser::tokenBranches8237 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8241, x64Parser::tokenBranches8241 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8283_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8283_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8283(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8283_16; - operand.values[17] = tokenCoding8283_17; - operand.values[18] = tokenCoding8283_18; - operand.values[19] = tokenCoding8283_19; -} -x64Token x64Parser::tokenBranches8282[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8283, - }, - {x64Token::EOT}}; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8283(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8283_16; + operand.values[17] = tokenCoding8283_17; + operand.values[18] = tokenCoding8283_18; + operand.values[19] = tokenCoding8283_19; +} +x64Token x64Parser::tokenBranches8282[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8283, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8285_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8285_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8285(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8285_16; - operand.values[17] = tokenCoding8285_17; - operand.values[18] = tokenCoding8285_18; - operand.values[19] = tokenCoding8285_19; -} -x64Token x64Parser::tokenBranches8284[] = {{ - x64Token::ADDRESSCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8285, - }, - {x64Token::EOT}}; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8285(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8285_16; + operand.values[17] = tokenCoding8285_17; + operand.values[18] = tokenCoding8285_18; + operand.values[19] = tokenCoding8285_19; +} +x64Token x64Parser::tokenBranches8284[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8285, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8293_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8293_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8293(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8293_16; - operand.values[17] = tokenCoding8293_17; - operand.values[18] = tokenCoding8293_18; - operand.values[19] = tokenCoding8293_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8293_16; + operand.values[17] = tokenCoding8293_17; + operand.values[18] = tokenCoding8293_18; + operand.values[19] = tokenCoding8293_19; } Coding x64Parser::tokenCoding8297_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8297_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8297(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8297_16; - operand.values[17] = tokenCoding8297_17; - operand.values[23] = tokenCoding8297_23; - operand.values[18] = tokenCoding8297_18; - operand.values[19] = tokenCoding8297_19; -} -x64Token x64Parser::tokenBranches8292[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8293, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8297, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8291[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8290[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8297_16; + operand.values[17] = tokenCoding8297_17; + operand.values[23] = tokenCoding8297_23; + operand.values[18] = tokenCoding8297_18; + operand.values[19] = tokenCoding8297_19; +} +x64Token x64Parser::tokenBranches8292[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8293, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8297, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8291[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8290[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8301_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8301_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8301(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8301_16; - operand.values[17] = tokenCoding8301_17; - operand.values[18] = tokenCoding8301_18; - operand.values[19] = tokenCoding8301_19; -} -x64Token x64Parser::tokenBranches8300[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8301, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8299[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8298[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8301_16; + operand.values[17] = tokenCoding8301_17; + operand.values[18] = tokenCoding8301_18; + operand.values[19] = tokenCoding8301_19; +} +x64Token x64Parser::tokenBranches8300[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8301, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8299[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8298[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8305_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8305_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8305(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8305_16; - operand.values[17] = tokenCoding8305_17; - operand.values[18] = tokenCoding8305_18; - operand.values[19] = tokenCoding8305_19; -} -x64Token x64Parser::tokenBranches8304[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8305, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8303[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8302[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8305_16; + operand.values[17] = tokenCoding8305_17; + operand.values[18] = tokenCoding8305_18; + operand.values[19] = tokenCoding8305_19; +} +x64Token x64Parser::tokenBranches8304[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8305, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8303[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8302[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8309_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8309_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8309(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8309_16; - operand.values[17] = tokenCoding8309_17; - operand.values[18] = tokenCoding8309_18; - operand.values[19] = tokenCoding8309_19; -} -x64Token x64Parser::tokenBranches8308[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8309, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8307[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8306[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8289[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8313(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 722; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8312[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8313, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8311[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312}, {x64Token::EOT}}; -void x64Parser::TokenFunc8316(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 723; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8315[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8316, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8314[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315}, {x64Token::EOT}}; -void x64Parser::TokenFunc8319(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 724; - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8318[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8319, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8317[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318}, {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8309_16; + operand.values[17] = tokenCoding8309_17; + operand.values[18] = tokenCoding8309_18; + operand.values[19] = tokenCoding8309_19; +} +x64Token x64Parser::tokenBranches8308[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8309, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8307[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8306[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8289[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 722; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8312[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8313, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8311[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 723; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8315[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8316, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8314[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 724; + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8318[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8319, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8317[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8340_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8340_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 4}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8340(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8340_16; - operand.values[17] = tokenCoding8340_17; - operand.values[18] = tokenCoding8340_18; - operand.values[19] = tokenCoding8340_19; -} -x64Token x64Parser::tokenBranches8339[] = {{ - x64Token::ADDRESSCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8340, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8322(x64Operand& operand, int tokenPos) { operand.operandCoding = 722; } -x64Token x64Parser::tokenBranches8321[] = {{ - x64Token::REGISTER, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8322, - }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8320[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 4 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8340(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8340_16; + operand.values[17] = tokenCoding8340_17; + operand.values[18] = tokenCoding8340_18; + operand.values[19] = tokenCoding8340_19; +} +x64Token x64Parser::tokenBranches8339[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8340, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 722; +} +x64Token x64Parser::tokenBranches8321[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8322, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8344_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8344_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 5}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8344(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8344_16; - operand.values[17] = tokenCoding8344_17; - operand.values[18] = tokenCoding8344_18; - operand.values[19] = tokenCoding8344_19; -} -x64Token x64Parser::tokenBranches8343[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8344, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8325(x64Operand& operand, int tokenPos) { operand.operandCoding = 723; } -x64Token x64Parser::tokenBranches8324[] = {{ - x64Token::REGISTER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8325, - }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8323[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 5 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8344(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8344_16; + operand.values[17] = tokenCoding8344_17; + operand.values[18] = tokenCoding8344_18; + operand.values[19] = tokenCoding8344_19; +} +x64Token x64Parser::tokenBranches8343[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8344, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 723; +} +x64Token x64Parser::tokenBranches8324[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8325, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8323[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8348_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8348_19[] = { - {CODING_NAME("rm") Coding::stateFunc, 6}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8348(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8348_16; - operand.values[17] = tokenCoding8348_17; - operand.values[18] = tokenCoding8348_18; - operand.values[19] = tokenCoding8348_19; -} -x64Token x64Parser::tokenBranches8347[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8348, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8328(x64Operand& operand, int tokenPos) { operand.operandCoding = 724; } -x64Token x64Parser::tokenBranches8327[] = {{ - x64Token::REGISTER, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8328, - }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8326[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327}, {x64Token::EOT}}; + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8348(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8348_16; + operand.values[17] = tokenCoding8348_17; + operand.values[18] = tokenCoding8348_18; + operand.values[19] = tokenCoding8348_19; +} +x64Token x64Parser::tokenBranches8347[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8348, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 724; +} +x64Token x64Parser::tokenBranches8327[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8328, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8332_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8332_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8332(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8332_16; - operand.values[17] = tokenCoding8332_17; - operand.values[18] = tokenCoding8332_18; - operand.values[19] = tokenCoding8332_19; -} -x64Token x64Parser::tokenBranches8331[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8332, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8330[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8329[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8332_16; + operand.values[17] = tokenCoding8332_17; + operand.values[18] = tokenCoding8332_18; + operand.values[19] = tokenCoding8332_19; +} +x64Token x64Parser::tokenBranches8331[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8332, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8330[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8329[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8336_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8336_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8336(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8336_16; - operand.values[17] = tokenCoding8336_17; - operand.values[23] = tokenCoding8336_23; - operand.values[18] = tokenCoding8336_18; - operand.values[19] = tokenCoding8336_19; -} -x64Token x64Parser::tokenBranches8335[] = {{ - x64Token::ADDRESSCLASS, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8336, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8334[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8333[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8336(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8336_16; + operand.values[17] = tokenCoding8336_17; + operand.values[23] = tokenCoding8336_23; + operand.values[18] = tokenCoding8336_18; + operand.values[19] = tokenCoding8336_19; +} +x64Token x64Parser::tokenBranches8335[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8336, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8334[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8333[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8352_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8352_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8352(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8352_16; - operand.values[17] = tokenCoding8352_17; - operand.values[18] = tokenCoding8352_18; - operand.values[19] = tokenCoding8352_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8352_16; + operand.values[17] = tokenCoding8352_17; + operand.values[18] = tokenCoding8352_18; + operand.values[19] = tokenCoding8352_19; } Coding x64Parser::tokenCoding8356_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8356_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8356(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8356_16; - operand.values[17] = tokenCoding8356_17; - operand.values[23] = tokenCoding8356_23; - operand.values[18] = tokenCoding8356_18; - operand.values[19] = tokenCoding8356_19; -} -x64Token x64Parser::tokenBranches8351[] = {{ - x64Token::REGISTERCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8352, - }, - { - x64Token::REGISTERCLASS, - 14, - 1, - 0, - NULL, - &x64Parser::TokenFunc8356, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8350[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8349[] = {{x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8356_16; + operand.values[17] = tokenCoding8356_17; + operand.values[23] = tokenCoding8356_23; + operand.values[18] = tokenCoding8356_18; + operand.values[19] = tokenCoding8356_19; +} +x64Token x64Parser::tokenBranches8351[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8352, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8356, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8350[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8349[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8360_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8360_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 4}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8360(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8360_16; - operand.values[17] = tokenCoding8360_17; - operand.values[18] = tokenCoding8360_18; - operand.values[19] = tokenCoding8360_19; -} -x64Token x64Parser::tokenBranches8359[] = {{ - x64Token::REGISTERCLASS, - 4, - 1, - 0, - NULL, - &x64Parser::TokenFunc8360, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8358[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8357[] = {{x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 4 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8360_16; + operand.values[17] = tokenCoding8360_17; + operand.values[18] = tokenCoding8360_18; + operand.values[19] = tokenCoding8360_19; +} +x64Token x64Parser::tokenBranches8359[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8360, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8358[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8357[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8364_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8364_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 5}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8364(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8364_16; - operand.values[17] = tokenCoding8364_17; - operand.values[18] = tokenCoding8364_18; - operand.values[19] = tokenCoding8364_19; -} -x64Token x64Parser::tokenBranches8363[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8364, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8362[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8361[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362}, - {x64Token::EOT}}; + { CODING_NAME("modreg") Coding::stateFunc, 5 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8364_16; + operand.values[17] = tokenCoding8364_17; + operand.values[18] = tokenCoding8364_18; + operand.values[19] = tokenCoding8364_19; +} +x64Token x64Parser::tokenBranches8363[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8364, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8362[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8361[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8368_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8368_19[] = { - {CODING_NAME("modreg") Coding::stateFunc, 6}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8368(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8368_16; - operand.values[17] = tokenCoding8368_17; - operand.values[18] = tokenCoding8368_18; - operand.values[19] = tokenCoding8368_19; -} -x64Token x64Parser::tokenBranches8367[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8368, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8366[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8365[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8320(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8323(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8326(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8329(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8333(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") Coding::stateFunc, 6 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8368_16; + operand.values[17] = tokenCoding8368_17; + operand.values[18] = tokenCoding8368_18; + operand.values[19] = tokenCoding8368_19; +} +x64Token x64Parser::tokenBranches8367[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8368, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8366[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8365[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8310[] = { - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311}, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314}, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317}, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL, &x64Parser::TokenFunc8320, x64Parser::tokenBranches8320}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8323, x64Parser::tokenBranches8323}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8326, x64Parser::tokenBranches8326}, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL, &x64Parser::TokenFunc8329, x64Parser::tokenBranches8329}, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL, &x64Parser::TokenFunc8333, x64Parser::tokenBranches8333}, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349}, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357}, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361}, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365}, - {x64Token::EOT}}; -void x64Parser::TokenFunc8375(x64Operand& operand, int tokenPos) { operand.operandCoding = 725; } -x64Token x64Parser::tokenBranches8374[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8375, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8387(x64Operand& operand, int tokenPos) { operand.operandCoding = 727; } -x64Token x64Parser::tokenBranches8386[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8387, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8399(x64Operand& operand, int tokenPos) { operand.operandCoding = 729; } -x64Token x64Parser::tokenBranches8398[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8399, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8373[] = {{x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374}, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386}, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8372[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373}, {x64Token::EOT}}; -void x64Parser::TokenFunc8381(x64Operand& operand, int tokenPos) { operand.operandCoding = 726; } -x64Token x64Parser::tokenBranches8380[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8381, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8393(x64Operand& operand, int tokenPos) { operand.operandCoding = 728; } -x64Token x64Parser::tokenBranches8392[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8393, - }, - {x64Token::EOT}}; -void x64Parser::TokenFunc8405(x64Operand& operand, int tokenPos) { operand.operandCoding = 730; } -x64Token x64Parser::tokenBranches8404[] = {{ - x64Token::TOKEN, - 2, - 1, - 0, - NULL, - &x64Parser::TokenFunc8405, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8379[] = {{x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8380}, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8392}, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8404}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8378[] = {{x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379}, {x64Token::EOT}}; -void x64Parser::TokenFunc8378(x64Operand& operand, int tokenPos) -{ - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8320, x64Parser::tokenBranches8320 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8323, x64Parser::tokenBranches8323 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8333, x64Parser::tokenBranches8333 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8375(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 725; +} +x64Token x64Parser::tokenBranches8374[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8375, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 727; +} +x64Token x64Parser::tokenBranches8386[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 729; +} +x64Token x64Parser::tokenBranches8398[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8373[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8372[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8381(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 726; +} +x64Token x64Parser::tokenBranches8380[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8381, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8393(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 728; +} +x64Token x64Parser::tokenBranches8392[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8393, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8405(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 730; +} +x64Token x64Parser::tokenBranches8404[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8405, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8379[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8380 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8392 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8404 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8378[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8371[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372}, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL, &x64Parser::TokenFunc8378, x64Parser::tokenBranches8378}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8370[] = {{x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371}, {x64Token::EOT}}; -void x64Parser::TokenFunc8406(x64Operand& operand, int tokenPos) { operand.operandCoding = 731; } -x64Token x64Parser::tokenBranches8369[] = {{x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370}, - { - x64Token::EMPTY, - 0, - 1, - 0, - NULL, - &x64Parser::TokenFunc8406, - }, - {x64Token::EOT}}; + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8378, x64Parser::tokenBranches8378 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8370[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8406(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 731; +} +x64Token x64Parser::tokenBranches8369[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8406, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8410_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8410_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8410(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8410_16; - operand.values[17] = tokenCoding8410_17; - operand.values[18] = tokenCoding8410_18; - operand.values[19] = tokenCoding8410_19; -} -x64Token x64Parser::tokenBranches8409[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8410, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8410(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8410_16; + operand.values[17] = tokenCoding8410_17; + operand.values[18] = tokenCoding8410_18; + operand.values[19] = tokenCoding8410_19; +} +x64Token x64Parser::tokenBranches8409[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8410, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8412_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8412_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8412(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8412_16; - operand.values[17] = tokenCoding8412_17; - operand.values[18] = tokenCoding8412_18; - operand.values[19] = tokenCoding8412_19; -} -x64Token x64Parser::tokenBranches8411[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8412, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8412_16; + operand.values[17] = tokenCoding8412_17; + operand.values[18] = tokenCoding8412_18; + operand.values[19] = tokenCoding8412_19; +} +x64Token x64Parser::tokenBranches8411[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8412, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8414_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8414_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8414(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8414_16; - operand.values[17] = tokenCoding8414_17; - operand.values[18] = tokenCoding8414_18; - operand.values[19] = tokenCoding8414_19; -} -x64Token x64Parser::tokenBranches8413[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8414, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8414(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8414_16; + operand.values[17] = tokenCoding8414_17; + operand.values[18] = tokenCoding8414_18; + operand.values[19] = tokenCoding8414_19; +} +x64Token x64Parser::tokenBranches8413[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8414, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8416_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8416_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8416(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8416_16; - operand.values[17] = tokenCoding8416_17; - operand.values[18] = tokenCoding8416_18; - operand.values[19] = tokenCoding8416_19; -} -x64Token x64Parser::tokenBranches8415[] = {{ - x64Token::ADDRESSCLASS, - 1, - 1, - 0, - NULL, - &x64Parser::TokenFunc8416, - }, - {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8416_16; + operand.values[17] = tokenCoding8416_17; + operand.values[18] = tokenCoding8416_18; + operand.values[19] = tokenCoding8416_19; +} +x64Token x64Parser::tokenBranches8415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8469_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8469_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8469(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8469_16; - operand.values[17] = tokenCoding8469_17; - operand.values[23] = tokenCoding8469_23; - operand.values[18] = tokenCoding8469_18; - operand.values[19] = tokenCoding8469_19; -} -x64Token x64Parser::tokenBranches8468[] = {{ - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8469, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8467[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468}, {x64Token::EOT}}; -void x64Parser::TokenFunc8467(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8469(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8469_16; + operand.values[17] = tokenCoding8469_17; + operand.values[23] = tokenCoding8469_23; + operand.values[18] = tokenCoding8469_18; + operand.values[19] = tokenCoding8469_19; +} +x64Token x64Parser::tokenBranches8468[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8469, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8467[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8466[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8467, x64Parser::tokenBranches8467}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8467, x64Parser::tokenBranches8467 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8473_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8473_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8473(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8473_16; - operand.values[17] = tokenCoding8473_17; - operand.values[23] = tokenCoding8473_23; - operand.values[18] = tokenCoding8473_18; - operand.values[19] = tokenCoding8473_19; -} -x64Token x64Parser::tokenBranches8472[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8473, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8471[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472}, {x64Token::EOT}}; -void x64Parser::TokenFunc8471(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8473_16; + operand.values[17] = tokenCoding8473_17; + operand.values[23] = tokenCoding8473_23; + operand.values[18] = tokenCoding8473_18; + operand.values[19] = tokenCoding8473_19; +} +x64Token x64Parser::tokenBranches8472[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8473, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8471[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8470[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8471, x64Parser::tokenBranches8471}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8471, x64Parser::tokenBranches8471 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8490_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8490_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8490(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8490_16; - operand.values[17] = tokenCoding8490_17; - operand.values[23] = tokenCoding8490_23; - operand.values[18] = tokenCoding8490_18; - operand.values[19] = tokenCoding8490_19; -} -x64Token x64Parser::tokenBranches8489[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8490, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8488[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8490(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8490_16; + operand.values[17] = tokenCoding8490_17; + operand.values[23] = tokenCoding8490_23; + operand.values[18] = tokenCoding8490_18; + operand.values[19] = tokenCoding8490_19; +} +x64Token x64Parser::tokenBranches8489[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8490, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8488[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8493_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8493_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8493(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8493_16; - operand.values[17] = tokenCoding8493_17; - operand.values[23] = tokenCoding8493_23; - operand.values[18] = tokenCoding8493_18; - operand.values[19] = tokenCoding8493_19; -} -x64Token x64Parser::tokenBranches8492[] = {{ - x64Token::ADDRESSCLASS, - 5, - 1, - 0, - NULL, - &x64Parser::TokenFunc8493, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8491[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8493(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8493_16; + operand.values[17] = tokenCoding8493_17; + operand.values[23] = tokenCoding8493_23; + operand.values[18] = tokenCoding8493_18; + operand.values[19] = tokenCoding8493_19; +} +x64Token x64Parser::tokenBranches8492[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8493, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8491[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8496_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8496_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8496(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8496_16; - operand.values[17] = tokenCoding8496_17; - operand.values[23] = tokenCoding8496_23; - operand.values[18] = tokenCoding8496_18; - operand.values[19] = tokenCoding8496_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8496_16; + operand.values[17] = tokenCoding8496_17; + operand.values[23] = tokenCoding8496_23; + operand.values[18] = tokenCoding8496_18; + operand.values[19] = tokenCoding8496_19; } Coding x64Parser::tokenCoding8499_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8499_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8499(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8499_16; - operand.values[17] = tokenCoding8499_17; - operand.values[23] = tokenCoding8499_23; - operand.values[18] = tokenCoding8499_18; - operand.values[19] = tokenCoding8499_19; -} -x64Token x64Parser::tokenBranches8495[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8496, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8499, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8494[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495}, {x64Token::EOT}}; -void x64Parser::TokenFunc8488(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8491(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8499_16; + operand.values[17] = tokenCoding8499_17; + operand.values[23] = tokenCoding8499_23; + operand.values[18] = tokenCoding8499_18; + operand.values[19] = tokenCoding8499_19; +} +x64Token x64Parser::tokenBranches8495[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8496, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8499, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8494[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8487[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8488, x64Parser::tokenBranches8488}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8491, x64Parser::tokenBranches8491}, - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8488, x64Parser::tokenBranches8488 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8491, x64Parser::tokenBranches8491 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8503_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8503_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8503(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8503_16; - operand.values[17] = tokenCoding8503_17; - operand.values[23] = tokenCoding8503_23; - operand.values[18] = tokenCoding8503_18; - operand.values[19] = tokenCoding8503_19; -} -x64Token x64Parser::tokenBranches8502[] = {{ - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8503, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8501[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8503_16; + operand.values[17] = tokenCoding8503_17; + operand.values[23] = tokenCoding8503_23; + operand.values[18] = tokenCoding8503_18; + operand.values[19] = tokenCoding8503_19; +} +x64Token x64Parser::tokenBranches8502[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8503, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8501[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8506_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8506_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8506(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8506_16; - operand.values[17] = tokenCoding8506_17; - operand.values[23] = tokenCoding8506_23; - operand.values[18] = tokenCoding8506_18; - operand.values[19] = tokenCoding8506_19; -} -x64Token x64Parser::tokenBranches8505[] = {{ - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8506, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8504[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8506(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8506_16; + operand.values[17] = tokenCoding8506_17; + operand.values[23] = tokenCoding8506_23; + operand.values[18] = tokenCoding8506_18; + operand.values[19] = tokenCoding8506_19; +} +x64Token x64Parser::tokenBranches8505[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8506, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8504[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8509_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8509_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8509(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8509_16; - operand.values[17] = tokenCoding8509_17; - operand.values[23] = tokenCoding8509_23; - operand.values[18] = tokenCoding8509_18; - operand.values[19] = tokenCoding8509_19; + operand.values[16] = tokenCoding8509_16; + operand.values[17] = tokenCoding8509_17; + operand.values[23] = tokenCoding8509_23; + operand.values[18] = tokenCoding8509_18; + operand.values[19] = tokenCoding8509_19; } Coding x64Parser::tokenCoding8512_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8512_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8512(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8512_16; - operand.values[17] = tokenCoding8512_17; - operand.values[23] = tokenCoding8512_23; - operand.values[18] = tokenCoding8512_18; - operand.values[19] = tokenCoding8512_19; -} -x64Token x64Parser::tokenBranches8508[] = {{ - x64Token::ADDRESSCLASS, - 21, - 1, - 0, - NULL, - &x64Parser::TokenFunc8509, - }, - { - x64Token::ADDRESSCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8512, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8507[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8512_16; + operand.values[17] = tokenCoding8512_17; + operand.values[23] = tokenCoding8512_23; + operand.values[18] = tokenCoding8512_18; + operand.values[19] = tokenCoding8512_19; +} +x64Token x64Parser::tokenBranches8508[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8509, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8507[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8515_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8515_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8515(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8515_16; - operand.values[17] = tokenCoding8515_17; - operand.values[23] = tokenCoding8515_23; - operand.values[18] = tokenCoding8515_18; - operand.values[19] = tokenCoding8515_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8515_16; + operand.values[17] = tokenCoding8515_17; + operand.values[23] = tokenCoding8515_23; + operand.values[18] = tokenCoding8515_18; + operand.values[19] = tokenCoding8515_19; } Coding x64Parser::tokenCoding8521_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8521(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8521_16; - operand.values[17] = tokenCoding8521_17; - operand.values[23] = tokenCoding8521_23; - operand.values[18] = tokenCoding8521_18; - operand.values[19] = tokenCoding8521_19; -} -x64Token x64Parser::tokenBranches8514[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8515, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8521, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8513[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514}, {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8521(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8521_16; + operand.values[17] = tokenCoding8521_17; + operand.values[23] = tokenCoding8521_23; + operand.values[18] = tokenCoding8521_18; + operand.values[19] = tokenCoding8521_19; +} +x64Token x64Parser::tokenBranches8514[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8515, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8521, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8513[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8518_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8518_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8518(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8518_16; - operand.values[17] = tokenCoding8518_17; - operand.values[23] = tokenCoding8518_23; - operand.values[18] = tokenCoding8518_18; - operand.values[19] = tokenCoding8518_19; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8518_16; + operand.values[17] = tokenCoding8518_17; + operand.values[23] = tokenCoding8518_23; + operand.values[18] = tokenCoding8518_18; + operand.values[19] = tokenCoding8518_19; } Coding x64Parser::tokenCoding8524_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8524(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8524_16; - operand.values[17] = tokenCoding8524_17; - operand.values[23] = tokenCoding8524_23; - operand.values[18] = tokenCoding8524_18; - operand.values[19] = tokenCoding8524_19; -} -x64Token x64Parser::tokenBranches8517[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8518, - }, - { - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8524, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8516[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517}, {x64Token::EOT}}; -void x64Parser::TokenFunc8504(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8507(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8524_16; + operand.values[17] = tokenCoding8524_17; + operand.values[23] = tokenCoding8524_23; + operand.values[18] = tokenCoding8524_18; + operand.values[19] = tokenCoding8524_19; +} +x64Token x64Parser::tokenBranches8517[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8518, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8524, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8516[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8500[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501}, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8504, x64Parser::tokenBranches8504}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8507, x64Parser::tokenBranches8507}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513}, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516}, - {x64Token::EOT}}; + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8504, x64Parser::tokenBranches8504 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8507, x64Parser::tokenBranches8507 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8532_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8532_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8532(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8532_16; - operand.values[17] = tokenCoding8532_17; - operand.values[23] = tokenCoding8532_23; - operand.values[18] = tokenCoding8532_18; - operand.values[19] = tokenCoding8532_19; -} -x64Token x64Parser::tokenBranches8531[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc8532, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8530[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531}, {x64Token::EOT}}; -void x64Parser::TokenFunc8530(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8532(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8532_16; + operand.values[17] = tokenCoding8532_17; + operand.values[23] = tokenCoding8532_23; + operand.values[18] = tokenCoding8532_18; + operand.values[19] = tokenCoding8532_19; +} +x64Token x64Parser::tokenBranches8531[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8532, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8530[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8529[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8530, x64Parser::tokenBranches8530}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8530, x64Parser::tokenBranches8530 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8538_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8538_19[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8538(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8538_16; - operand.values[17] = tokenCoding8538_17; - operand.values[23] = tokenCoding8538_23; - operand.values[18] = tokenCoding8538_18; - operand.values[19] = tokenCoding8538_19; -} -x64Token x64Parser::tokenBranches8537[] = {{ - x64Token::ADDRESSCLASS, - 27, - 1, - 0, - NULL, - &x64Parser::TokenFunc8538, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8536[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537}, {x64Token::EOT}}; -void x64Parser::TokenFunc8536(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8538_16; + operand.values[17] = tokenCoding8538_17; + operand.values[23] = tokenCoding8538_23; + operand.values[18] = tokenCoding8538_18; + operand.values[19] = tokenCoding8538_19; +} +x64Token x64Parser::tokenBranches8537[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8535[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8536, x64Parser::tokenBranches8536}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8546_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8546_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8546(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8546_16; - operand.values[17] = tokenCoding8546_17; - operand.values[23] = tokenCoding8546_23; - operand.values[18] = tokenCoding8546_18; - operand.values[19] = tokenCoding8546_19; -} -x64Token x64Parser::tokenBranches8545[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8546, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8544[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8543[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8546_16; + operand.values[17] = tokenCoding8546_17; + operand.values[23] = tokenCoding8546_23; + operand.values[18] = tokenCoding8546_18; + operand.values[19] = tokenCoding8546_19; +} +x64Token x64Parser::tokenBranches8545[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8546, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8544[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8543[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8550_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8550_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8550_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8550(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8550_16; - operand.values[17] = tokenCoding8550_17; - operand.values[18] = tokenCoding8550_18; + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8550_16; + operand.values[17] = tokenCoding8550_17; + operand.values[18] = tokenCoding8550_18; } Coding x64Parser::tokenCoding8553_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8553_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8553_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8553(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8553_16; - operand.values[17] = tokenCoding8553_17; - operand.values[18] = tokenCoding8553_18; -} -x64Token x64Parser::tokenBranches8549[] = {{ - x64Token::REGISTERCLASS, - 7, - 1, - 0, - NULL, - &x64Parser::TokenFunc8550, - }, - { - x64Token::REGISTERCLASS, - 10, - 1, - 0, - NULL, - &x64Parser::TokenFunc8553, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8548[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8547[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8553_16; + operand.values[17] = tokenCoding8553_17; + operand.values[18] = tokenCoding8553_18; +} +x64Token x64Parser::tokenBranches8549[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8550, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8553, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8548[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8547[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8557_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_23[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8557_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8557(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8557_16; - operand.values[17] = tokenCoding8557_17; - operand.values[23] = tokenCoding8557_23; - operand.values[18] = tokenCoding8557_18; - operand.values[19] = tokenCoding8557_19; -} -x64Token x64Parser::tokenBranches8556[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8557, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8555[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8554[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8557_16; + operand.values[17] = tokenCoding8557_17; + operand.values[23] = tokenCoding8557_23; + operand.values[18] = tokenCoding8557_18; + operand.values[19] = tokenCoding8557_19; +} +x64Token x64Parser::tokenBranches8556[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8557, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8555[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8554[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8561_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8561_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8561(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8561_16; - operand.values[17] = tokenCoding8561_17; - operand.values[23] = tokenCoding8561_23; - operand.values[18] = tokenCoding8561_18; - operand.values[19] = tokenCoding8561_19; -} -x64Token x64Parser::tokenBranches8560[] = {{ - x64Token::REGISTERCLASS, - 17, - 1, - 0, - NULL, - &x64Parser::TokenFunc8561, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8559[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8558[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8561_16; + operand.values[17] = tokenCoding8561_17; + operand.values[23] = tokenCoding8561_23; + operand.values[18] = tokenCoding8561_18; + operand.values[19] = tokenCoding8561_19; +} +x64Token x64Parser::tokenBranches8560[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8561, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8559[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8558[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8565_16[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_17[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_18[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8565_19[] = { - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("modreg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8565(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8565_16; - operand.values[17] = tokenCoding8565_17; - operand.values[23] = tokenCoding8565_23; - operand.values[18] = tokenCoding8565_18; - operand.values[19] = tokenCoding8565_19; -} -x64Token x64Parser::tokenBranches8564[] = {{ - x64Token::REGISTERCLASS, - 18, - 1, - 0, - NULL, - &x64Parser::TokenFunc8565, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8563[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8562[] = {{x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563}, - {x64Token::EOT}}; + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8565_16; + operand.values[17] = tokenCoding8565_17; + operand.values[23] = tokenCoding8565_23; + operand.values[18] = tokenCoding8565_18; + operand.values[19] = tokenCoding8565_19; +} +x64Token x64Parser::tokenBranches8564[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8565, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8563[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8562[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8569_16[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_17[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_23[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_18[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8569_19[] = { - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("reg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8569(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8569_16; - operand.values[17] = tokenCoding8569_17; - operand.values[23] = tokenCoding8569_23; - operand.values[18] = tokenCoding8569_18; - operand.values[19] = tokenCoding8569_19; -} -x64Token x64Parser::tokenBranches8568[] = {{ - x64Token::ADDRESSCLASS, - 24, - 1, - 0, - NULL, - &x64Parser::TokenFunc8569, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8567[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568}, {x64Token::EOT}}; -void x64Parser::TokenFunc8567(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8569(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8569_16; + operand.values[17] = tokenCoding8569_17; + operand.values[23] = tokenCoding8569_23; + operand.values[18] = tokenCoding8569_18; + operand.values[19] = tokenCoding8569_19; +} +x64Token x64Parser::tokenBranches8568[] = { + {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8569, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8566[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8567, x64Parser::tokenBranches8567}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8567, x64Parser::tokenBranches8567 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8597_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8597_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8597(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8597_16; - operand.values[17] = tokenCoding8597_17; - operand.values[23] = tokenCoding8597_23; - operand.values[18] = tokenCoding8597_18; -} -x64Token x64Parser::tokenBranches8596[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8597, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8595[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8594[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8593[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8597_16; + operand.values[17] = tokenCoding8597_17; + operand.values[23] = tokenCoding8597_23; + operand.values[18] = tokenCoding8597_18; +} +x64Token x64Parser::tokenBranches8596[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8597, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8595[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8594[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8593[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8602_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8602_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8602(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8602_16; - operand.values[17] = tokenCoding8602_17; - operand.values[23] = tokenCoding8602_23; - operand.values[18] = tokenCoding8602_18; -} -x64Token x64Parser::tokenBranches8601[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8602, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8600[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8599[] = {{x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8598[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599}, {x64Token::EOT}}; -void x64Parser::TokenFunc8593(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8598(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8602_16; + operand.values[17] = tokenCoding8602_17; + operand.values[23] = tokenCoding8602_23; + operand.values[18] = tokenCoding8602_18; +} +x64Token x64Parser::tokenBranches8601[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8602, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8600[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8599[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8598[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8598(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8592[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8593, x64Parser::tokenBranches8593}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8598, x64Parser::tokenBranches8598}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8593, x64Parser::tokenBranches8593 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8598, x64Parser::tokenBranches8598 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8621_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8621_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8621(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8621_16; - operand.values[17] = tokenCoding8621_17; - operand.values[23] = tokenCoding8621_23; - operand.values[18] = tokenCoding8621_18; -} -x64Token x64Parser::tokenBranches8620[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8621, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8619[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620}, {x64Token::EOT}}; -void x64Parser::TokenFunc8619(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8621(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8621_16; + operand.values[17] = tokenCoding8621_17; + operand.values[23] = tokenCoding8621_23; + operand.values[18] = tokenCoding8621_18; +} +x64Token x64Parser::tokenBranches8620[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8621, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8619[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8618[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8619, x64Parser::tokenBranches8619}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8617[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8616[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8619, x64Parser::tokenBranches8619 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8617[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8616[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8627_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8627_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8627(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8627_16; - operand.values[17] = tokenCoding8627_17; - operand.values[23] = tokenCoding8627_23; - operand.values[18] = tokenCoding8627_18; -} -x64Token x64Parser::tokenBranches8626[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8627, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8625[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8626}, {x64Token::EOT}}; -void x64Parser::TokenFunc8625(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8627(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8627_16; + operand.values[17] = tokenCoding8627_17; + operand.values[23] = tokenCoding8627_23; + operand.values[18] = tokenCoding8627_18; +} +x64Token x64Parser::tokenBranches8626[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8627, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8625[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8626 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8625(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8624[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8625, x64Parser::tokenBranches8625}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8623[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8624}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8622[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8623}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8625, x64Parser::tokenBranches8625 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8623[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8624 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8622[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8623 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8633_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8633(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8633_16; - operand.values[17] = tokenCoding8633_17; - operand.values[23] = tokenCoding8633_23; - operand.values[18] = tokenCoding8633_18; -} -x64Token x64Parser::tokenBranches8632[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8633, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8631[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8632}, {x64Token::EOT}}; -void x64Parser::TokenFunc8631(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8633(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8633_16; + operand.values[17] = tokenCoding8633_17; + operand.values[23] = tokenCoding8633_23; + operand.values[18] = tokenCoding8633_18; +} +x64Token x64Parser::tokenBranches8632[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8633, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8631[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8632 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8631(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8630[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8631, x64Parser::tokenBranches8631}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8629[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8630}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8628[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8631, x64Parser::tokenBranches8631 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8630 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8628[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8639_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8639(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8639_16; - operand.values[17] = tokenCoding8639_17; - operand.values[23] = tokenCoding8639_23; - operand.values[18] = tokenCoding8639_18; - operand.values[19] = tokenCoding8639_19; -} -x64Token x64Parser::tokenBranches8638[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8639, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8637[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8638}, {x64Token::EOT}}; -void x64Parser::TokenFunc8637(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8639_16; + operand.values[17] = tokenCoding8639_17; + operand.values[23] = tokenCoding8639_23; + operand.values[18] = tokenCoding8639_18; + operand.values[19] = tokenCoding8639_19; +} +x64Token x64Parser::tokenBranches8638[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8639, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8637[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8638 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8637(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8636[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8637, x64Parser::tokenBranches8637}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8635[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8644_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8644_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8644(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8644_16; - operand.values[17] = tokenCoding8644_17; - operand.values[23] = tokenCoding8644_23; - operand.values[18] = tokenCoding8644_18; - operand.values[19] = tokenCoding8644_19; -} -x64Token x64Parser::tokenBranches8643[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8644, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8642[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8641[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8640[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8644_16; + operand.values[17] = tokenCoding8644_17; + operand.values[23] = tokenCoding8644_23; + operand.values[18] = tokenCoding8644_18; + operand.values[19] = tokenCoding8644_19; +} +x64Token x64Parser::tokenBranches8643[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8644, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8642[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8641[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8640[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8649_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8649_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8649(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8649_16; - operand.values[17] = tokenCoding8649_17; - operand.values[23] = tokenCoding8649_23; - operand.values[18] = tokenCoding8649_18; - operand.values[19] = tokenCoding8649_19; -} -x64Token x64Parser::tokenBranches8648[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8649, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8647[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8646[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8645[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8649_16; + operand.values[17] = tokenCoding8649_17; + operand.values[23] = tokenCoding8649_23; + operand.values[18] = tokenCoding8649_18; + operand.values[19] = tokenCoding8649_19; +} +x64Token x64Parser::tokenBranches8648[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8649, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8647[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8646[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8645[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8654_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8654_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8654(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8654_16; - operand.values[17] = tokenCoding8654_17; - operand.values[23] = tokenCoding8654_23; - operand.values[18] = tokenCoding8654_18; - operand.values[19] = tokenCoding8654_19; -} -x64Token x64Parser::tokenBranches8653[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8654, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8652[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653}, {x64Token::EOT}}; -void x64Parser::TokenFunc8652(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8654_16; + operand.values[17] = tokenCoding8654_17; + operand.values[23] = tokenCoding8654_23; + operand.values[18] = tokenCoding8654_18; + operand.values[19] = tokenCoding8654_19; +} +x64Token x64Parser::tokenBranches8653[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8654, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8652[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8652(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8651[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8652, x64Parser::tokenBranches8652}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8650[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651}, {x64Token::EOT}}; -void x64Parser::TokenFunc8640(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8645(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8652, x64Parser::tokenBranches8652 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8650[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8640(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8634[] = { - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635}, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8640, x64Parser::tokenBranches8640}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8645, x64Parser::tokenBranches8645}, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650}, - {x64Token::EOT}}; + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8640, x64Parser::tokenBranches8640 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8645, x64Parser::tokenBranches8645 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8660_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8660_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8660(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8660_16; - operand.values[17] = tokenCoding8660_17; - operand.values[23] = tokenCoding8660_23; - operand.values[18] = tokenCoding8660_18; -} -x64Token x64Parser::tokenBranches8659[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8660, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8658[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8657[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8656[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657}, {x64Token::EOT}}; -void x64Parser::TokenFunc8656(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8660_16; + operand.values[17] = tokenCoding8660_17; + operand.values[23] = tokenCoding8660_23; + operand.values[18] = tokenCoding8660_18; +} +x64Token x64Parser::tokenBranches8659[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8660, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8658[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8657[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8656[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8655[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8656, x64Parser::tokenBranches8656}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8656, x64Parser::tokenBranches8656 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8666_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8666_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8666(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8666_16; - operand.values[17] = tokenCoding8666_17; - operand.values[23] = tokenCoding8666_23; - operand.values[18] = tokenCoding8666_18; -} -x64Token x64Parser::tokenBranches8665[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8666, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8664[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8665}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8663[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8664}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8662[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8663}, {x64Token::EOT}}; -void x64Parser::TokenFunc8662(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8666(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8666_16; + operand.values[17] = tokenCoding8666_17; + operand.values[23] = tokenCoding8666_23; + operand.values[18] = tokenCoding8666_18; +} +x64Token x64Parser::tokenBranches8665[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8666, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8664[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8665 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8663[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8664 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8662[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8663 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8662(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8661[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8662, x64Parser::tokenBranches8662}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8662, x64Parser::tokenBranches8662 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8672_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8672(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8672_16; - operand.values[17] = tokenCoding8672_17; - operand.values[23] = tokenCoding8672_23; - operand.values[18] = tokenCoding8672_18; -} -x64Token x64Parser::tokenBranches8671[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8672, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8670[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8671}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8669[] = {{x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8668[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8669}, {x64Token::EOT}}; -void x64Parser::TokenFunc8668(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8672(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8672_16; + operand.values[17] = tokenCoding8672_17; + operand.values[23] = tokenCoding8672_23; + operand.values[18] = tokenCoding8672_18; +} +x64Token x64Parser::tokenBranches8671[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8672, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8670[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8671 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8669[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8668[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8669 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8668(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8667[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8668, x64Parser::tokenBranches8668}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8668, x64Parser::tokenBranches8668 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8678_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8678(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8678_16; - operand.values[17] = tokenCoding8678_17; - operand.values[23] = tokenCoding8678_23; - operand.values[18] = tokenCoding8678_18; - operand.values[19] = tokenCoding8678_19; -} -x64Token x64Parser::tokenBranches8677[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8678, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8676[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8677}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8675[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8674[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8678_16; + operand.values[17] = tokenCoding8678_17; + operand.values[23] = tokenCoding8678_23; + operand.values[18] = tokenCoding8678_18; + operand.values[19] = tokenCoding8678_19; +} +x64Token x64Parser::tokenBranches8677[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8678, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8676[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8677 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8675[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8674[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8683_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8683_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8683(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8683_16; - operand.values[17] = tokenCoding8683_17; - operand.values[23] = tokenCoding8683_23; - operand.values[18] = tokenCoding8683_18; - operand.values[19] = tokenCoding8683_19; -} -x64Token x64Parser::tokenBranches8682[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8683, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8681[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8683_16; + operand.values[17] = tokenCoding8683_17; + operand.values[23] = tokenCoding8683_23; + operand.values[18] = tokenCoding8683_18; + operand.values[19] = tokenCoding8683_19; +} +x64Token x64Parser::tokenBranches8682[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8683, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8688_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8688_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8688(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8688_16; - operand.values[17] = tokenCoding8688_17; - operand.values[23] = tokenCoding8688_23; - operand.values[18] = tokenCoding8688_18; - operand.values[19] = tokenCoding8688_19; -} -x64Token x64Parser::tokenBranches8687[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8688, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8686[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687}, {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8688_16; + operand.values[17] = tokenCoding8688_17; + operand.values[23] = tokenCoding8688_23; + operand.values[18] = tokenCoding8688_18; + operand.values[19] = tokenCoding8688_19; +} +x64Token x64Parser::tokenBranches8687[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8688, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8686[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8693_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_23[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8693_19[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("imm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8693(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8693_16; - operand.values[17] = tokenCoding8693_17; - operand.values[23] = tokenCoding8693_23; - operand.values[18] = tokenCoding8693_18; - operand.values[19] = tokenCoding8693_19; -} -x64Token x64Parser::tokenBranches8692[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8693, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8691[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8680[] = {{x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681}, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686}, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8679[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680}, {x64Token::EOT}}; -void x64Parser::TokenFunc8674(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8679(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8693_16; + operand.values[17] = tokenCoding8693_17; + operand.values[23] = tokenCoding8693_23; + operand.values[18] = tokenCoding8693_18; + operand.values[19] = tokenCoding8693_19; +} +x64Token x64Parser::tokenBranches8692[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8693, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8691[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8680[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8679[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8673[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8674, x64Parser::tokenBranches8674}, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL, &x64Parser::TokenFunc8679, x64Parser::tokenBranches8679}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8679, x64Parser::tokenBranches8679 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8702_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8702_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8702(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8702(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8702_16; - operand.values[17] = tokenCoding8702_17; - operand.values[23] = tokenCoding8702_23; - operand.values[18] = tokenCoding8702_18; + operand.values[16] = tokenCoding8702_16; + operand.values[17] = tokenCoding8702_17; + operand.values[23] = tokenCoding8702_23; + operand.values[18] = tokenCoding8702_18; } Coding x64Parser::tokenCoding8708_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8708_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8708(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8708_16; - operand.values[17] = tokenCoding8708_17; - operand.values[23] = tokenCoding8708_23; - operand.values[18] = tokenCoding8708_18; -} -x64Token x64Parser::tokenBranches8701[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8702, - }, - { - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8708, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8700[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701}, {x64Token::EOT}}; + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8708_16; + operand.values[17] = tokenCoding8708_17; + operand.values[23] = tokenCoding8708_23; + operand.values[18] = tokenCoding8708_18; +} +x64Token x64Parser::tokenBranches8701[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8702, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8708, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8700[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8705_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8705_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8705(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8705(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8705_16; - operand.values[17] = tokenCoding8705_17; - operand.values[23] = tokenCoding8705_23; - operand.values[18] = tokenCoding8705_18; + operand.values[16] = tokenCoding8705_16; + operand.values[17] = tokenCoding8705_17; + operand.values[23] = tokenCoding8705_23; + operand.values[18] = tokenCoding8705_18; } Coding x64Parser::tokenCoding8711_16[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_17[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_23[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8711_18[] = { - {CODING_NAME("rm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8711(x64Operand& operand, int tokenPos) -{ - operand.values[16] = tokenCoding8711_16; - operand.values[17] = tokenCoding8711_17; - operand.values[23] = tokenCoding8711_23; - operand.values[18] = tokenCoding8711_18; -} -x64Token x64Parser::tokenBranches8704[] = {{ - x64Token::ADDRESSCLASS, - 8, - 1, - 0, - NULL, - &x64Parser::TokenFunc8705, - }, - { - x64Token::ADDRESSCLASS, - 9, - 1, - 0, - NULL, - &x64Parser::TokenFunc8711, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8703[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704}, {x64Token::EOT}}; -void x64Parser::TokenFunc8700(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8703(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding8711_16; + operand.values[17] = tokenCoding8711_17; + operand.values[23] = tokenCoding8711_23; + operand.values[18] = tokenCoding8711_18; +} +x64Token x64Parser::tokenBranches8704[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8705, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8711, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8703[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8699[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL, &x64Parser::TokenFunc8700, x64Parser::tokenBranches8700}, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL, &x64Parser::TokenFunc8703, x64Parser::tokenBranches8703}, - {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8700, x64Parser::tokenBranches8700 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8703, x64Parser::tokenBranches8703 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8725_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8725_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8725_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8725(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8725_16; - operand.values[17] = tokenCoding8725_17; - operand.values[18] = tokenCoding8725_18; -} -x64Token x64Parser::tokenBranches8724[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8725, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8723[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8722[] = {{x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723}, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8721[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722}, {x64Token::EOT}}; -void x64Parser::TokenFunc8721(x64Operand& operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8725_16; + operand.values[17] = tokenCoding8725_17; + operand.values[18] = tokenCoding8725_18; +} +x64Token x64Parser::tokenBranches8724[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8725, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8723[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8722[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8721[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8720[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL, &x64Parser::TokenFunc8721, x64Parser::tokenBranches8721}, {x64Token::EOT}}; + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8721, x64Parser::tokenBranches8721 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8730_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8730_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8730_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -void x64Parser::TokenFunc8730(x64Operand& operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8730_16; - operand.values[17] = tokenCoding8730_17; - operand.values[18] = tokenCoding8730_18; -} -x64Token x64Parser::tokenBranches8729[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8730, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8728[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8727[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728}, - {x64Token::EOT}}; + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8730_16; + operand.values[17] = tokenCoding8730_17; + operand.values[18] = tokenCoding8730_18; +} +x64Token x64Parser::tokenBranches8729[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8730, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8728[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8727[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8739_16[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8739_17[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8739_18[] = { - {CODING_NAME("imm")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8739(x64Operand& operand, int tokenPos) +void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) { - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8739_16; - operand.values[17] = tokenCoding8739_17; - operand.values[18] = tokenCoding8739_18; + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8739_16; + operand.values[17] = tokenCoding8739_17; + operand.values[18] = tokenCoding8739_18; } -x64Token x64Parser::tokenBranches8738[] = {{ - x64Token::NUMBER, - 3, - 1, - 0, - NULL, - &x64Parser::TokenFunc8739, - }, - {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8737[] = {{x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738}, {x64Token::EOT}}; -x64Token x64Parser::tokenBranches8736[] = {{x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737}, - {x64Token::EOT}}; -asmError x64Parser::Opcode0(x64Operand& operand) +x64Token x64Parser::tokenBranches8738[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8739, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8737[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8736[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737 }, + {x64Token::EOT } +}; +asmError x64Parser::Opcode0(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5267, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5267, operand); + return rv; } -asmError x64Parser::Opcode1(x64Operand& operand) +asmError x64Parser::Opcode1(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5269, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5269, operand); + return rv; } -asmError x64Parser::Opcode2(x64Operand& operand) +asmError x64Parser::Opcode2(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5271, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5271, operand); + return rv; } -asmError x64Parser::Opcode3(x64Operand& operand) +asmError x64Parser::Opcode3(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5296, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5296, operand); + return rv; } -asmError x64Parser::Opcode4(x64Operand& operand) +asmError x64Parser::Opcode4(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5309, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5309, operand); + return rv; } -asmError x64Parser::Opcode5(x64Operand& operand) +asmError x64Parser::Opcode5(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5483, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5483, operand); + return rv; } -asmError x64Parser::Opcode6(x64Operand& operand) +asmError x64Parser::Opcode6(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5511, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5511, operand); + return rv; } -asmError x64Parser::Opcode7(x64Operand& operand) +asmError x64Parser::Opcode7(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5527, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5527, operand); + return rv; } -asmError x64Parser::Opcode8(x64Operand& operand) +asmError x64Parser::Opcode8(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5540, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5540, operand); + return rv; } -asmError x64Parser::Opcode9(x64Operand& operand) +asmError x64Parser::Opcode9(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5552, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5552, operand); + return rv; } -asmError x64Parser::Opcode10(x64Operand& operand) +asmError x64Parser::Opcode10(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5558, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5558, operand); + return rv; } -asmError x64Parser::Opcode11(x64Operand& operand) +asmError x64Parser::Opcode11(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5563, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5563, operand); + return rv; } -asmError x64Parser::Opcode12(x64Operand& operand) +asmError x64Parser::Opcode12(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5566, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5566, operand); + return rv; } -asmError x64Parser::Opcode13(x64Operand& operand) +asmError x64Parser::Opcode13(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5575, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5575, operand); + return rv; } -asmError x64Parser::Opcode14(x64Operand& operand) +asmError x64Parser::Opcode14(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5588, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5588, operand); + return rv; } -asmError x64Parser::Opcode15(x64Operand& operand) +asmError x64Parser::Opcode15(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5591, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5591, operand); + return rv; } -asmError x64Parser::Opcode16(x64Operand& operand) +asmError x64Parser::Opcode16(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5634, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5634, operand); + return rv; } -asmError x64Parser::Opcode17(x64Operand& operand) +asmError x64Parser::Opcode17(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5729, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5729, operand); + return rv; } -asmError x64Parser::Opcode18(x64Operand& operand) +asmError x64Parser::Opcode18(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5766, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5766, operand); + return rv; } -asmError x64Parser::Opcode19(x64Operand& operand) +asmError x64Parser::Opcode19(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5768, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5768, operand); + return rv; } -asmError x64Parser::Opcode20(x64Operand& operand) +asmError x64Parser::Opcode20(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5772, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5772, operand); + return rv; } -asmError x64Parser::Opcode21(x64Operand& operand) +asmError x64Parser::Opcode21(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5779, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5779, operand); + return rv; } -asmError x64Parser::Opcode22(x64Operand& operand) +asmError x64Parser::Opcode22(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5786, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5786, operand); + return rv; } -asmError x64Parser::Opcode23(x64Operand& operand) +asmError x64Parser::Opcode23(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5793, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5793, operand); + return rv; } -asmError x64Parser::Opcode24(x64Operand& operand) +asmError x64Parser::Opcode24(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5797, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5797, operand); + return rv; } -asmError x64Parser::Opcode25(x64Operand& operand) +asmError x64Parser::Opcode25(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5801, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5801, operand); + return rv; } -asmError x64Parser::Opcode26(x64Operand& operand) +asmError x64Parser::Opcode26(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5808, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5808, operand); + return rv; } -asmError x64Parser::Opcode27(x64Operand& operand) +asmError x64Parser::Opcode27(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5817, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5817, operand); + return rv; } -asmError x64Parser::Opcode28(x64Operand& operand) +asmError x64Parser::Opcode28(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5824, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5824, operand); + return rv; } -asmError x64Parser::Opcode29(x64Operand& operand) +asmError x64Parser::Opcode29(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5830, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5830, operand); + return rv; } -asmError x64Parser::Opcode30(x64Operand& operand) +asmError x64Parser::Opcode30(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5843, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5843, operand); + return rv; } -asmError x64Parser::Opcode31(x64Operand& operand) +asmError x64Parser::Opcode31(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5849, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5849, operand); + return rv; } Coding x64Parser::OpcodeCodings32_19[] = { - {CODING_NAME("aaa") Coding::stateFunc, 7}, - {CODING_NAME("aaa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 55, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aaa") Coding::stateFunc, 7 }, + { CODING_NAME("aaa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 55, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode32(x64Operand& operand) +asmError x64Parser::Opcode32(x64Operand &operand) { - operand.values[19] = OpcodeCodings32_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings32_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings33_19[] = { - {CODING_NAME("aad") Coding::stateFunc, 7}, - {CODING_NAME("aad")(Coding::Type)(Coding::valSpecified), 213, 0, 0, 0, 0}, - {CODING_NAME("aad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aad") Coding::stateFunc, 7 }, + { CODING_NAME("aad") (Coding::Type)(Coding::valSpecified), 213, 0, 0, 0, 0 }, + { CODING_NAME("aad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode33(x64Operand& operand) +asmError x64Parser::Opcode33(x64Operand &operand) { - operand.values[19] = OpcodeCodings33_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings33_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings34_19[] = { - {CODING_NAME("aam") Coding::stateFunc, 7}, - {CODING_NAME("aam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0}, - {CODING_NAME("aam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aam") Coding::stateFunc, 7 }, + { CODING_NAME("aam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, + { CODING_NAME("aam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode34(x64Operand& operand) +asmError x64Parser::Opcode34(x64Operand &operand) { - operand.values[19] = OpcodeCodings34_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings34_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings35_19[] = { - {CODING_NAME("aas") Coding::stateFunc, 7}, - {CODING_NAME("aas")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 63, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("aas") Coding::stateFunc, 7 }, + { CODING_NAME("aas") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 63, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode35(x64Operand& operand) +asmError x64Parser::Opcode35(x64Operand &operand) { - operand.values[19] = OpcodeCodings35_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings35_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings36_18[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings36_36[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings36_37[] = { - {CODING_NAME("adc")(Coding::Type)(Coding::valSpecified), 16, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("adc") (Coding::Type)(Coding::valSpecified), 16, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode36(x64Operand& operand) +asmError x64Parser::Opcode36(x64Operand &operand) { - operand.values[18] = OpcodeCodings36_18; - operand.values[36] = OpcodeCodings36_36; - operand.values[37] = OpcodeCodings36_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings36_18; + operand.values[36] = OpcodeCodings36_36; + operand.values[37] = OpcodeCodings36_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings37_18[] = { - {CODING_NAME("add")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings37_36[] = { - {CODING_NAME("add")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings37_37[] = { - {CODING_NAME("add")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("add") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode37(x64Operand& operand) +asmError x64Parser::Opcode37(x64Operand &operand) { - operand.values[18] = OpcodeCodings37_18; - operand.values[36] = OpcodeCodings37_36; - operand.values[37] = OpcodeCodings37_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings37_18; + operand.values[36] = OpcodeCodings37_36; + operand.values[37] = OpcodeCodings37_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings38_18[] = { - {CODING_NAME("and")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings38_36[] = { - {CODING_NAME("and")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings38_37[] = { - {CODING_NAME("and")(Coding::Type)(Coding::valSpecified), 32, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("and") (Coding::Type)(Coding::valSpecified), 32, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode38(x64Operand& operand) +asmError x64Parser::Opcode38(x64Operand &operand) { - operand.values[18] = OpcodeCodings38_18; - operand.values[36] = OpcodeCodings38_36; - operand.values[37] = OpcodeCodings38_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings38_18; + operand.values[36] = OpcodeCodings38_36; + operand.values[37] = OpcodeCodings38_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode39(x64Operand& operand) +asmError x64Parser::Opcode39(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5862, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5862, operand); + return rv; } Coding x64Parser::OpcodeCodings40_36[] = { - {CODING_NAME("bound") Coding::stateFunc, 7}, - {CODING_NAME("bound")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bound") Coding::stateFunc, 7 }, + { CODING_NAME("bound") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode40(x64Operand& operand) +asmError x64Parser::Opcode40(x64Operand &operand) { - operand.values[36] = OpcodeCodings40_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings40_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings41_36[] = { - {CODING_NAME("bsf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bsf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 188, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bsf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bsf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 188, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode41(x64Operand& operand) +asmError x64Parser::Opcode41(x64Operand &operand) { - operand.values[36] = OpcodeCodings41_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings41_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings42_36[] = { - {CODING_NAME("bsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 189, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 189, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode42(x64Operand& operand) +asmError x64Parser::Opcode42(x64Operand &operand) { - operand.values[36] = OpcodeCodings42_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings42_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } -asmError x64Parser::Opcode43(x64Operand& operand) +asmError x64Parser::Opcode43(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5869, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5869, operand); + return rv; } Coding x64Parser::OpcodeCodings44_18[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings44_36[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings44_37[] = { - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode44(x64Operand& operand) +asmError x64Parser::Opcode44(x64Operand &operand) { - operand.values[18] = OpcodeCodings44_18; - operand.values[36] = OpcodeCodings44_36; - operand.values[37] = OpcodeCodings44_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings44_18; + operand.values[36] = OpcodeCodings44_36; + operand.values[37] = OpcodeCodings44_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings45_18[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings45_36[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings45_37[] = { - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 187, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 187, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode45(x64Operand& operand) +asmError x64Parser::Opcode45(x64Operand &operand) { - operand.values[18] = OpcodeCodings45_18; - operand.values[36] = OpcodeCodings45_36; - operand.values[37] = OpcodeCodings45_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings45_18; + operand.values[36] = OpcodeCodings45_36; + operand.values[37] = OpcodeCodings45_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings46_18[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings46_36[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings46_37[] = { - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("btr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 179, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("btr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 179, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode46(x64Operand& operand) +asmError x64Parser::Opcode46(x64Operand &operand) { - operand.values[18] = OpcodeCodings46_18; - operand.values[36] = OpcodeCodings46_36; - operand.values[37] = OpcodeCodings46_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings46_18; + operand.values[36] = OpcodeCodings46_36; + operand.values[37] = OpcodeCodings46_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } Coding x64Parser::OpcodeCodings47_18[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings47_36[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 186, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings47_37[] = { - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("bts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("bts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode47(x64Operand& operand) +asmError x64Parser::Opcode47(x64Operand &operand) { - operand.values[18] = OpcodeCodings47_18; - operand.values[36] = OpcodeCodings47_36; - operand.values[37] = OpcodeCodings47_37; - asmError rv; - { - rv = Opcode5(operand); - } - return rv; + operand.values[18] = OpcodeCodings47_18; + operand.values[36] = OpcodeCodings47_36; + operand.values[37] = OpcodeCodings47_37; + asmError rv; + { + rv = Opcode5(operand); + } + return rv; } -asmError x64Parser::Opcode48(x64Operand& operand) +asmError x64Parser::Opcode48(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5876, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5876, operand); + return rv; } Coding x64Parser::OpcodeCodings49_19[] = { - {CODING_NAME("cbw") Coding::stateFunc, 4}, - {CODING_NAME("cbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cbw") Coding::stateFunc, 4 }, + { CODING_NAME("cbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode49(x64Operand& operand) +asmError x64Parser::Opcode49(x64Operand &operand) { - operand.values[19] = OpcodeCodings49_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings49_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings50_19[] = { - {CODING_NAME("cdq") Coding::stateFunc, 5}, - {CODING_NAME("cdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cdq") Coding::stateFunc, 5 }, + { CODING_NAME("cdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode50(x64Operand& operand) +asmError x64Parser::Opcode50(x64Operand &operand) { - operand.values[19] = OpcodeCodings50_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings50_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode51(x64Operand& operand) +asmError x64Parser::Opcode51(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5911, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5911, operand); + return rv; } Coding x64Parser::OpcodeCodings52_19[] = { - {CODING_NAME("clc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("clc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode52(x64Operand& operand) +asmError x64Parser::Opcode52(x64Operand &operand) { - operand.values[19] = OpcodeCodings52_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings52_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings53_19[] = { - {CODING_NAME("cld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode53(x64Operand& operand) +asmError x64Parser::Opcode53(x64Operand &operand) { - operand.values[19] = OpcodeCodings53_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings53_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings54_19[] = { - {CODING_NAME("cli")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cli") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode54(x64Operand& operand) +asmError x64Parser::Opcode54(x64Operand &operand) { - operand.values[19] = OpcodeCodings54_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings54_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings55_19[] = { - {CODING_NAME("clts")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("clts") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode55(x64Operand& operand) +asmError x64Parser::Opcode55(x64Operand &operand) { - operand.values[19] = OpcodeCodings55_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings55_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings56_19[] = { - {CODING_NAME("cmc")(Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmc") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode56(x64Operand& operand) +asmError x64Parser::Opcode56(x64Operand &operand) { - operand.values[19] = OpcodeCodings56_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings56_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings57_38[] = { - {CODING_NAME("cmova")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmova") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode57(x64Operand& operand) +asmError x64Parser::Opcode57(x64Operand &operand) { - operand.values[38] = OpcodeCodings57_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings57_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings58_38[] = { - {CODING_NAME("cmovae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode58(x64Operand& operand) +asmError x64Parser::Opcode58(x64Operand &operand) { - operand.values[38] = OpcodeCodings58_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings58_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings59_38[] = { - {CODING_NAME("cmovb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode59(x64Operand& operand) +asmError x64Parser::Opcode59(x64Operand &operand) { - operand.values[38] = OpcodeCodings59_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings59_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings60_38[] = { - {CODING_NAME("cmovbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode60(x64Operand& operand) +asmError x64Parser::Opcode60(x64Operand &operand) { - operand.values[38] = OpcodeCodings60_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings60_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings61_38[] = { - {CODING_NAME("cmovc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode61(x64Operand& operand) +asmError x64Parser::Opcode61(x64Operand &operand) { - operand.values[38] = OpcodeCodings61_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings61_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings62_38[] = { - {CODING_NAME("cmove")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmove") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode62(x64Operand& operand) +asmError x64Parser::Opcode62(x64Operand &operand) { - operand.values[38] = OpcodeCodings62_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings62_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings63_38[] = { - {CODING_NAME("cmovg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode63(x64Operand& operand) +asmError x64Parser::Opcode63(x64Operand &operand) { - operand.values[38] = OpcodeCodings63_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings63_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings64_38[] = { - {CODING_NAME("cmovge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode64(x64Operand& operand) +asmError x64Parser::Opcode64(x64Operand &operand) { - operand.values[38] = OpcodeCodings64_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings64_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings65_38[] = { - {CODING_NAME("cmovl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode65(x64Operand& operand) +asmError x64Parser::Opcode65(x64Operand &operand) { - operand.values[38] = OpcodeCodings65_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings65_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings66_38[] = { - {CODING_NAME("cmovle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode66(x64Operand& operand) +asmError x64Parser::Opcode66(x64Operand &operand) { - operand.values[38] = OpcodeCodings66_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings66_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings67_38[] = { - {CODING_NAME("cmovna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode67(x64Operand& operand) +asmError x64Parser::Opcode67(x64Operand &operand) { - operand.values[38] = OpcodeCodings67_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings67_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings68_38[] = { - {CODING_NAME("cmovnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode68(x64Operand& operand) +asmError x64Parser::Opcode68(x64Operand &operand) { - operand.values[38] = OpcodeCodings68_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings68_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings69_38[] = { - {CODING_NAME("cmovnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode69(x64Operand& operand) +asmError x64Parser::Opcode69(x64Operand &operand) { - operand.values[38] = OpcodeCodings69_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings69_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings70_38[] = { - {CODING_NAME("cmovnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode70(x64Operand& operand) +asmError x64Parser::Opcode70(x64Operand &operand) { - operand.values[38] = OpcodeCodings70_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings70_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings71_38[] = { - {CODING_NAME("cmovnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode71(x64Operand& operand) +asmError x64Parser::Opcode71(x64Operand &operand) { - operand.values[38] = OpcodeCodings71_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings71_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings72_38[] = { - {CODING_NAME("cmovne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode72(x64Operand& operand) +asmError x64Parser::Opcode72(x64Operand &operand) { - operand.values[38] = OpcodeCodings72_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings72_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings73_38[] = { - {CODING_NAME("cmovng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode73(x64Operand& operand) +asmError x64Parser::Opcode73(x64Operand &operand) { - operand.values[38] = OpcodeCodings73_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings73_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings74_38[] = { - {CODING_NAME("cmovnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode74(x64Operand& operand) +asmError x64Parser::Opcode74(x64Operand &operand) { - operand.values[38] = OpcodeCodings74_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings74_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings75_38[] = { - {CODING_NAME("cmovnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode75(x64Operand& operand) +asmError x64Parser::Opcode75(x64Operand &operand) { - operand.values[38] = OpcodeCodings75_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings75_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings76_38[] = { - {CODING_NAME("cmovnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode76(x64Operand& operand) +asmError x64Parser::Opcode76(x64Operand &operand) { - operand.values[38] = OpcodeCodings76_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings76_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings77_38[] = { - {CODING_NAME("cmovno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode77(x64Operand& operand) +asmError x64Parser::Opcode77(x64Operand &operand) { - operand.values[38] = OpcodeCodings77_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings77_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings78_38[] = { - {CODING_NAME("cmovnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode78(x64Operand& operand) +asmError x64Parser::Opcode78(x64Operand &operand) { - operand.values[38] = OpcodeCodings78_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings78_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings79_38[] = { - {CODING_NAME("cmovns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode79(x64Operand& operand) +asmError x64Parser::Opcode79(x64Operand &operand) { - operand.values[38] = OpcodeCodings79_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings79_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings80_38[] = { - {CODING_NAME("cmovnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode80(x64Operand& operand) +asmError x64Parser::Opcode80(x64Operand &operand) { - operand.values[38] = OpcodeCodings80_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings80_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings81_38[] = { - {CODING_NAME("cmovo")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode81(x64Operand& operand) +asmError x64Parser::Opcode81(x64Operand &operand) { - operand.values[38] = OpcodeCodings81_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings81_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings82_38[] = { - {CODING_NAME("cmovp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode82(x64Operand& operand) +asmError x64Parser::Opcode82(x64Operand &operand) { - operand.values[38] = OpcodeCodings82_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings82_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings83_38[] = { - {CODING_NAME("cmovpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode83(x64Operand& operand) +asmError x64Parser::Opcode83(x64Operand &operand) { - operand.values[38] = OpcodeCodings83_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings83_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings84_38[] = { - {CODING_NAME("cmovpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode84(x64Operand& operand) +asmError x64Parser::Opcode84(x64Operand &operand) { - operand.values[38] = OpcodeCodings84_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings84_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings85_38[] = { - {CODING_NAME("cmovs")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovs") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode85(x64Operand& operand) +asmError x64Parser::Opcode85(x64Operand &operand) { - operand.values[38] = OpcodeCodings85_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings85_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings86_38[] = { - {CODING_NAME("cmovz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmovz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode86(x64Operand& operand) +asmError x64Parser::Opcode86(x64Operand &operand) { - operand.values[38] = OpcodeCodings86_38; - asmError rv; - { - rv = Opcode13(operand); - } - return rv; + operand.values[38] = OpcodeCodings86_38; + asmError rv; + { + rv = Opcode13(operand); + } + return rv; } Coding x64Parser::OpcodeCodings87_18[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings87_36[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 60, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 60, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings87_37[] = { - {CODING_NAME("cmp")(Coding::Type)(Coding::valSpecified), 56, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmp") (Coding::Type)(Coding::valSpecified), 56, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode87(x64Operand& operand) +asmError x64Parser::Opcode87(x64Operand &operand) { - operand.values[18] = OpcodeCodings87_18; - operand.values[36] = OpcodeCodings87_36; - operand.values[37] = OpcodeCodings87_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings87_18; + operand.values[36] = OpcodeCodings87_36; + operand.values[37] = OpcodeCodings87_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode88(x64Operand& operand) +asmError x64Parser::Opcode88(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches5949, operand); - return rv; + asmError rv = ParseOperands(tokenBranches5949, operand); + return rv; } Coding x64Parser::OpcodeCodings89_19[] = { - {CODING_NAME("cmpsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode89(x64Operand& operand) +asmError x64Parser::Opcode89(x64Operand &operand) { - operand.values[19] = OpcodeCodings89_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings89_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings90_19[] = { - {CODING_NAME("cmpsw") Coding::stateFunc, 4}, - {CODING_NAME("cmpsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsw") Coding::stateFunc, 4 }, + { CODING_NAME("cmpsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode90(x64Operand& operand) +asmError x64Parser::Opcode90(x64Operand &operand) { - operand.values[19] = OpcodeCodings90_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings90_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings91_19[] = { - {CODING_NAME("cmpsd") Coding::stateFunc, 5}, - {CODING_NAME("cmpsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpsd") Coding::stateFunc, 5 }, + { CODING_NAME("cmpsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode91(x64Operand& operand) +asmError x64Parser::Opcode91(x64Operand &operand) { - operand.values[19] = OpcodeCodings91_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings91_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode92(x64Operand& operand) +asmError x64Parser::Opcode92(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6217, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6217, operand); + return rv; } Coding x64Parser::OpcodeCodings93_36[] = { - {CODING_NAME("cmpxchg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmpxchg")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 176, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpxchg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpxchg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 176, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode93(x64Operand& operand) +asmError x64Parser::Opcode93(x64Operand &operand) { - operand.values[36] = OpcodeCodings93_36; - asmError rv = ParseOperands(tokenBranches6219, operand); - return rv; + operand.values[36] = OpcodeCodings93_36; + asmError rv = ParseOperands(tokenBranches6219, operand); + return rv; } -asmError x64Parser::Opcode94(x64Operand& operand) +asmError x64Parser::Opcode94(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6240, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6240, operand); + return rv; } -asmError x64Parser::Opcode95(x64Operand& operand) +asmError x64Parser::Opcode95(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6242, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6242, operand); + return rv; } Coding x64Parser::OpcodeCodings96_19[] = { - {CODING_NAME("cpuid")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cpuid") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode96(x64Operand& operand) +asmError x64Parser::Opcode96(x64Operand &operand) { - operand.values[19] = OpcodeCodings96_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings96_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode97(x64Operand& operand) +asmError x64Parser::Opcode97(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6245, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6245, operand); + return rv; } Coding x64Parser::OpcodeCodings98_19[] = { - {CODING_NAME("cwd") Coding::stateFunc, 4}, - {CODING_NAME("cwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cwd") Coding::stateFunc, 4 }, + { CODING_NAME("cwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode98(x64Operand& operand) +asmError x64Parser::Opcode98(x64Operand &operand) { - operand.values[19] = OpcodeCodings98_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings98_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings99_19[] = { - {CODING_NAME("cwde") Coding::stateFunc, 5}, - {CODING_NAME("cwde")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cwde") Coding::stateFunc, 5 }, + { CODING_NAME("cwde") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode99(x64Operand& operand) +asmError x64Parser::Opcode99(x64Operand &operand) { - operand.values[19] = OpcodeCodings99_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings99_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings100_19[] = { - {CODING_NAME("daa") Coding::stateFunc, 7}, - {CODING_NAME("daa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("daa") Coding::stateFunc, 7 }, + { CODING_NAME("daa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode100(x64Operand& operand) +asmError x64Parser::Opcode100(x64Operand &operand) { - operand.values[19] = OpcodeCodings100_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings100_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings101_19[] = { - {CODING_NAME("das") Coding::stateFunc, 7}, - {CODING_NAME("das")(Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("das") Coding::stateFunc, 7 }, + { CODING_NAME("das") (Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode101(x64Operand& operand) +asmError x64Parser::Opcode101(x64Operand &operand) { - operand.values[19] = OpcodeCodings101_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings101_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings102_18[] = { - {CODING_NAME("dec")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings102_19[] = { - {CODING_NAME("dec")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode102(x64Operand& operand) +asmError x64Parser::Opcode102(x64Operand &operand) { - operand.values[18] = OpcodeCodings102_18; - operand.values[19] = OpcodeCodings102_19; - asmError rv; - { - rv = Opcode6(operand); - } - return rv; + operand.values[18] = OpcodeCodings102_18; + operand.values[19] = OpcodeCodings102_19; + asmError rv; + { + rv = Opcode6(operand); + } + return rv; } Coding x64Parser::OpcodeCodings103_18[] = { - {CODING_NAME("div")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("div") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode103(x64Operand& operand) +asmError x64Parser::Opcode103(x64Operand &operand) { - operand.values[18] = OpcodeCodings103_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings103_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } -asmError x64Parser::Opcode104(x64Operand& operand) +asmError x64Parser::Opcode104(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6253, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6253, operand); + return rv; } -asmError x64Parser::Opcode105(x64Operand& operand) +asmError x64Parser::Opcode105(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6259, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6259, operand); + return rv; } Coding x64Parser::OpcodeCodings106_19[] = { - {CODING_NAME("f2xm1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("f2xm1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode106(x64Operand& operand) +asmError x64Parser::Opcode106(x64Operand &operand) { - operand.values[19] = OpcodeCodings106_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings106_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings107_19[] = { - {CODING_NAME("fabs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fabs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode107(x64Operand& operand) +asmError x64Parser::Opcode107(x64Operand &operand) { - operand.values[19] = OpcodeCodings107_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings107_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings108_18[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings108_39[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings108_36[] = { - {CODING_NAME("fadd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode108(x64Operand& operand) +asmError x64Parser::Opcode108(x64Operand &operand) { - operand.values[18] = OpcodeCodings108_18; - operand.values[39] = OpcodeCodings108_39; - operand.values[36] = OpcodeCodings108_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings108_18; + operand.values[39] = OpcodeCodings108_39; + operand.values[36] = OpcodeCodings108_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings109_18[] = { - {CODING_NAME("faddp")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("faddp") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings109_19[] = { - {CODING_NAME("faddp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("faddp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode109(x64Operand& operand) +asmError x64Parser::Opcode109(x64Operand &operand) { - operand.values[18] = OpcodeCodings109_18; - operand.values[19] = OpcodeCodings109_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings109_18; + operand.values[19] = OpcodeCodings109_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings110_18[] = { - {CODING_NAME("fbld")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbld") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings110_19[] = { - {CODING_NAME("fbld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode110(x64Operand& operand) +asmError x64Parser::Opcode110(x64Operand &operand) { - operand.values[18] = OpcodeCodings110_18; - operand.values[19] = OpcodeCodings110_19; - asmError rv; - { - rv = Opcode11(operand); - } - return rv; + operand.values[18] = OpcodeCodings110_18; + operand.values[19] = OpcodeCodings110_19; + asmError rv; + { + rv = Opcode11(operand); + } + return rv; } Coding x64Parser::OpcodeCodings111_18[] = { - {CODING_NAME("fbstp")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbstp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings111_19[] = { - {CODING_NAME("fbstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fbstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode111(x64Operand& operand) +asmError x64Parser::Opcode111(x64Operand &operand) { - operand.values[18] = OpcodeCodings111_18; - operand.values[19] = OpcodeCodings111_19; - asmError rv; - { - rv = Opcode11(operand); - } - return rv; + operand.values[18] = OpcodeCodings111_18; + operand.values[19] = OpcodeCodings111_19; + asmError rv; + { + rv = Opcode11(operand); + } + return rv; } Coding x64Parser::OpcodeCodings112_19[] = { - {CODING_NAME("fchs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fchs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode112(x64Operand& operand) +asmError x64Parser::Opcode112(x64Operand &operand) { - operand.values[19] = OpcodeCodings112_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings112_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings113_19[] = { - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode113(x64Operand& operand) +asmError x64Parser::Opcode113(x64Operand &operand) { - operand.values[19] = OpcodeCodings113_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings113_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings114_19[] = { - {CODING_NAME("fnclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fnclex")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode114(x64Operand& operand) +asmError x64Parser::Opcode114(x64Operand &operand) { - operand.values[19] = OpcodeCodings114_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings114_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings115_18[] = { - {CODING_NAME("fcmovb")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings115_36[] = { - {CODING_NAME("fcmovb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode115(x64Operand& operand) +asmError x64Parser::Opcode115(x64Operand &operand) { - operand.values[18] = OpcodeCodings115_18; - operand.values[36] = OpcodeCodings115_36; - asmError rv = ParseOperands(tokenBranches6272, operand); - return rv; + operand.values[18] = OpcodeCodings115_18; + operand.values[36] = OpcodeCodings115_36; + asmError rv = ParseOperands(tokenBranches6272, operand); + return rv; } Coding x64Parser::OpcodeCodings116_18[] = { - {CODING_NAME("fcmovbe")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings116_36[] = { - {CODING_NAME("fcmovbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode116(x64Operand& operand) +asmError x64Parser::Opcode116(x64Operand &operand) { - operand.values[18] = OpcodeCodings116_18; - operand.values[36] = OpcodeCodings116_36; - asmError rv = ParseOperands(tokenBranches6276, operand); - return rv; + operand.values[18] = OpcodeCodings116_18; + operand.values[36] = OpcodeCodings116_36; + asmError rv = ParseOperands(tokenBranches6276, operand); + return rv; } Coding x64Parser::OpcodeCodings117_18[] = { - {CODING_NAME("fcmove")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings117_36[] = { - {CODING_NAME("fcmove")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode117(x64Operand& operand) +asmError x64Parser::Opcode117(x64Operand &operand) { - operand.values[18] = OpcodeCodings117_18; - operand.values[36] = OpcodeCodings117_36; - asmError rv = ParseOperands(tokenBranches6280, operand); - return rv; + operand.values[18] = OpcodeCodings117_18; + operand.values[36] = OpcodeCodings117_36; + asmError rv = ParseOperands(tokenBranches6280, operand); + return rv; } Coding x64Parser::OpcodeCodings118_18[] = { - {CODING_NAME("fcmovnb")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings118_36[] = { - {CODING_NAME("fcmovnb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode118(x64Operand& operand) +asmError x64Parser::Opcode118(x64Operand &operand) { - operand.values[18] = OpcodeCodings118_18; - operand.values[36] = OpcodeCodings118_36; - asmError rv = ParseOperands(tokenBranches6284, operand); - return rv; + operand.values[18] = OpcodeCodings118_18; + operand.values[36] = OpcodeCodings118_36; + asmError rv = ParseOperands(tokenBranches6284, operand); + return rv; } Coding x64Parser::OpcodeCodings119_18[] = { - {CODING_NAME("fcmovnbe")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings119_36[] = { - {CODING_NAME("fcmovnbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode119(x64Operand& operand) +asmError x64Parser::Opcode119(x64Operand &operand) { - operand.values[18] = OpcodeCodings119_18; - operand.values[36] = OpcodeCodings119_36; - asmError rv = ParseOperands(tokenBranches6288, operand); - return rv; + operand.values[18] = OpcodeCodings119_18; + operand.values[36] = OpcodeCodings119_36; + asmError rv = ParseOperands(tokenBranches6288, operand); + return rv; } Coding x64Parser::OpcodeCodings120_18[] = { - {CODING_NAME("fcmovne")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings120_36[] = { - {CODING_NAME("fcmovne")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode120(x64Operand& operand) +asmError x64Parser::Opcode120(x64Operand &operand) { - operand.values[18] = OpcodeCodings120_18; - operand.values[36] = OpcodeCodings120_36; - asmError rv = ParseOperands(tokenBranches6292, operand); - return rv; + operand.values[18] = OpcodeCodings120_18; + operand.values[36] = OpcodeCodings120_36; + asmError rv = ParseOperands(tokenBranches6292, operand); + return rv; } Coding x64Parser::OpcodeCodings121_18[] = { - {CODING_NAME("fcmovnu")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings121_36[] = { - {CODING_NAME("fcmovnu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode121(x64Operand& operand) +asmError x64Parser::Opcode121(x64Operand &operand) { - operand.values[18] = OpcodeCodings121_18; - operand.values[36] = OpcodeCodings121_36; - asmError rv = ParseOperands(tokenBranches6296, operand); - return rv; + operand.values[18] = OpcodeCodings121_18; + operand.values[36] = OpcodeCodings121_36; + asmError rv = ParseOperands(tokenBranches6296, operand); + return rv; } Coding x64Parser::OpcodeCodings122_18[] = { - {CODING_NAME("fcmovu")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings122_36[] = { - {CODING_NAME("fcmovu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode122(x64Operand& operand) +asmError x64Parser::Opcode122(x64Operand &operand) { - operand.values[18] = OpcodeCodings122_18; - operand.values[36] = OpcodeCodings122_36; - asmError rv = ParseOperands(tokenBranches6300, operand); - return rv; + operand.values[18] = OpcodeCodings122_18; + operand.values[36] = OpcodeCodings122_36; + asmError rv = ParseOperands(tokenBranches6300, operand); + return rv; } Coding x64Parser::OpcodeCodings123_18[] = { - {CODING_NAME("fcom")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings123_36[] = { - {CODING_NAME("fcom")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode123(x64Operand& operand) +asmError x64Parser::Opcode123(x64Operand &operand) { - operand.values[18] = OpcodeCodings123_18; - operand.values[36] = OpcodeCodings123_36; - asmError rv = ParseOperands(tokenBranches6304, operand); - return rv; + operand.values[18] = OpcodeCodings123_18; + operand.values[36] = OpcodeCodings123_36; + asmError rv = ParseOperands(tokenBranches6304, operand); + return rv; } Coding x64Parser::OpcodeCodings124_18[] = { - {CODING_NAME("fcomi")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings124_36[] = { - {CODING_NAME("fcomi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode124(x64Operand& operand) +asmError x64Parser::Opcode124(x64Operand &operand) { - operand.values[18] = OpcodeCodings124_18; - operand.values[36] = OpcodeCodings124_36; - asmError rv = ParseOperands(tokenBranches6313, operand); - return rv; + operand.values[18] = OpcodeCodings124_18; + operand.values[36] = OpcodeCodings124_36; + asmError rv = ParseOperands(tokenBranches6313, operand); + return rv; } Coding x64Parser::OpcodeCodings125_18[] = { - {CODING_NAME("fcomip")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings125_36[] = { - {CODING_NAME("fcomip")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode125(x64Operand& operand) +asmError x64Parser::Opcode125(x64Operand &operand) { - operand.values[18] = OpcodeCodings125_18; - operand.values[36] = OpcodeCodings125_36; - asmError rv = ParseOperands(tokenBranches6317, operand); - return rv; + operand.values[18] = OpcodeCodings125_18; + operand.values[36] = OpcodeCodings125_36; + asmError rv = ParseOperands(tokenBranches6317, operand); + return rv; } Coding x64Parser::OpcodeCodings126_18[] = { - {CODING_NAME("fcomp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings126_36[] = { - {CODING_NAME("fcomp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode126(x64Operand& operand) +asmError x64Parser::Opcode126(x64Operand &operand) { - operand.values[18] = OpcodeCodings126_18; - operand.values[36] = OpcodeCodings126_36; - asmError rv = ParseOperands(tokenBranches6321, operand); - return rv; + operand.values[18] = OpcodeCodings126_18; + operand.values[36] = OpcodeCodings126_36; + asmError rv = ParseOperands(tokenBranches6321, operand); + return rv; } Coding x64Parser::OpcodeCodings127_19[] = { - {CODING_NAME("fcompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("fcompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode127(x64Operand& operand) +asmError x64Parser::Opcode127(x64Operand &operand) { - operand.values[19] = OpcodeCodings127_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings127_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings128_19[] = { - {CODING_NAME("fcos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fcos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode128(x64Operand& operand) +asmError x64Parser::Opcode128(x64Operand &operand) { - operand.values[19] = OpcodeCodings128_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings128_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings129_19[] = { - {CODING_NAME("fdecstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fdecstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode129(x64Operand& operand) +asmError x64Parser::Opcode129(x64Operand &operand) { - operand.values[19] = OpcodeCodings129_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings129_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings130_19[] = { - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fdisi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode130(x64Operand& operand) +asmError x64Parser::Opcode130(x64Operand &operand) { - operand.values[19] = OpcodeCodings130_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings130_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings131_18[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings131_39[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings131_36[] = { - {CODING_NAME("fdiv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode131(x64Operand& operand) +asmError x64Parser::Opcode131(x64Operand &operand) { - operand.values[18] = OpcodeCodings131_18; - operand.values[39] = OpcodeCodings131_39; - operand.values[36] = OpcodeCodings131_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings131_18; + operand.values[39] = OpcodeCodings131_39; + operand.values[36] = OpcodeCodings131_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings132_18[] = { - {CODING_NAME("fdivp")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings132_19[] = { - {CODING_NAME("fdivp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode132(x64Operand& operand) +asmError x64Parser::Opcode132(x64Operand &operand) { - operand.values[18] = OpcodeCodings132_18; - operand.values[19] = OpcodeCodings132_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings132_18; + operand.values[19] = OpcodeCodings132_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings133_18[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings133_39[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings133_36[] = { - {CODING_NAME("fdivr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode133(x64Operand& operand) +asmError x64Parser::Opcode133(x64Operand &operand) { - operand.values[18] = OpcodeCodings133_18; - operand.values[39] = OpcodeCodings133_39; - operand.values[36] = OpcodeCodings133_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings133_18; + operand.values[39] = OpcodeCodings133_39; + operand.values[36] = OpcodeCodings133_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings134_18[] = { - {CODING_NAME("fdivrp")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivrp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings134_19[] = { - {CODING_NAME("fdivrp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fdivrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode134(x64Operand& operand) +asmError x64Parser::Opcode134(x64Operand &operand) { - operand.values[18] = OpcodeCodings134_18; - operand.values[19] = OpcodeCodings134_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings134_18; + operand.values[19] = OpcodeCodings134_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings135_19[] = { - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("feni")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode135(x64Operand& operand) +asmError x64Parser::Opcode135(x64Operand &operand) { - operand.values[19] = OpcodeCodings135_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings135_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode136(x64Operand& operand) +asmError x64Parser::Opcode136(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6336, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6336, operand); + return rv; } -asmError x64Parser::Opcode137(x64Operand& operand) +asmError x64Parser::Opcode137(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6338, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6338, operand); + return rv; } Coding x64Parser::OpcodeCodings138_18[] = { - {CODING_NAME("fiadd")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fiadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings138_36[] = { - {CODING_NAME("fiadd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fiadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode138(x64Operand& operand) +asmError x64Parser::Opcode138(x64Operand &operand) { - operand.values[18] = OpcodeCodings138_18; - operand.values[36] = OpcodeCodings138_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings138_18; + operand.values[36] = OpcodeCodings138_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings139_18[] = { - {CODING_NAME("ficom")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings139_36[] = { - {CODING_NAME("ficom")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode139(x64Operand& operand) +asmError x64Parser::Opcode139(x64Operand &operand) { - operand.values[18] = OpcodeCodings139_18; - operand.values[36] = OpcodeCodings139_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings139_18; + operand.values[36] = OpcodeCodings139_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings140_18[] = { - {CODING_NAME("ficomp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings140_36[] = { - {CODING_NAME("ficomp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ficomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode140(x64Operand& operand) +asmError x64Parser::Opcode140(x64Operand &operand) { - operand.values[18] = OpcodeCodings140_18; - operand.values[36] = OpcodeCodings140_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings140_18; + operand.values[36] = OpcodeCodings140_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings141_18[] = { - {CODING_NAME("fidiv")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings141_36[] = { - {CODING_NAME("fidiv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode141(x64Operand& operand) +asmError x64Parser::Opcode141(x64Operand &operand) { - operand.values[18] = OpcodeCodings141_18; - operand.values[36] = OpcodeCodings141_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings141_18; + operand.values[36] = OpcodeCodings141_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings142_18[] = { - {CODING_NAME("fidivr")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings142_36[] = { - {CODING_NAME("fidivr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fidivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode142(x64Operand& operand) +asmError x64Parser::Opcode142(x64Operand &operand) { - operand.values[18] = OpcodeCodings142_18; - operand.values[36] = OpcodeCodings142_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings142_18; + operand.values[36] = OpcodeCodings142_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings143_18[] = { - {CODING_NAME("fild")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fild") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings143_36[] = { - {CODING_NAME("fild")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fild") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode143(x64Operand& operand) +asmError x64Parser::Opcode143(x64Operand &operand) { - operand.values[18] = OpcodeCodings143_18; - operand.values[36] = OpcodeCodings143_36; - asmError rv = ParseOperands(tokenBranches6345, operand); - return rv; + operand.values[18] = OpcodeCodings143_18; + operand.values[36] = OpcodeCodings143_36; + asmError rv = ParseOperands(tokenBranches6345, operand); + return rv; } Coding x64Parser::OpcodeCodings144_18[] = { - {CODING_NAME("fimul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fimul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings144_36[] = { - {CODING_NAME("fimul")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fimul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode144(x64Operand& operand) +asmError x64Parser::Opcode144(x64Operand &operand) { - operand.values[18] = OpcodeCodings144_18; - operand.values[36] = OpcodeCodings144_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings144_18; + operand.values[36] = OpcodeCodings144_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings145_19[] = { - {CODING_NAME("fincstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fincstp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode145(x64Operand& operand) +asmError x64Parser::Opcode145(x64Operand &operand) { - operand.values[19] = OpcodeCodings145_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings145_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings146_19[] = { - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("finit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode146(x64Operand& operand) +asmError x64Parser::Opcode146(x64Operand &operand) { - operand.values[19] = OpcodeCodings146_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings146_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings147_19[] = { - {CODING_NAME("fninit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fninit")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode147(x64Operand& operand) +asmError x64Parser::Opcode147(x64Operand &operand) { - operand.values[19] = OpcodeCodings147_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings147_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings148_18[] = { - {CODING_NAME("fist")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fist") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings148_36[] = { - {CODING_NAME("fist")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fist") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode148(x64Operand& operand) +asmError x64Parser::Opcode148(x64Operand &operand) { - operand.values[18] = OpcodeCodings148_18; - operand.values[36] = OpcodeCodings148_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings148_18; + operand.values[36] = OpcodeCodings148_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings149_18[] = { - {CODING_NAME("fistp")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fistp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings149_36[] = { - {CODING_NAME("fistp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fistp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode149(x64Operand& operand) +asmError x64Parser::Opcode149(x64Operand &operand) { - operand.values[18] = OpcodeCodings149_18; - operand.values[36] = OpcodeCodings149_36; - asmError rv = ParseOperands(tokenBranches6357, operand); - return rv; + operand.values[18] = OpcodeCodings149_18; + operand.values[36] = OpcodeCodings149_36; + asmError rv = ParseOperands(tokenBranches6357, operand); + return rv; } Coding x64Parser::OpcodeCodings150_18[] = { - {CODING_NAME("fisub")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings150_36[] = { - {CODING_NAME("fisub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode150(x64Operand& operand) +asmError x64Parser::Opcode150(x64Operand &operand) { - operand.values[18] = OpcodeCodings150_18; - operand.values[36] = OpcodeCodings150_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings150_18; + operand.values[36] = OpcodeCodings150_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } Coding x64Parser::OpcodeCodings151_18[] = { - {CODING_NAME("fisubr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings151_36[] = { - {CODING_NAME("fisubr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fisubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode151(x64Operand& operand) +asmError x64Parser::Opcode151(x64Operand &operand) { - operand.values[18] = OpcodeCodings151_18; - operand.values[36] = OpcodeCodings151_36; - asmError rv; - { - rv = Opcode10(operand); - } - return rv; + operand.values[18] = OpcodeCodings151_18; + operand.values[36] = OpcodeCodings151_36; + asmError rv; + { + rv = Opcode10(operand); + } + return rv; } -asmError x64Parser::Opcode152(x64Operand& operand) +asmError x64Parser::Opcode152(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6364, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6364, operand); + return rv; } Coding x64Parser::OpcodeCodings153_19[] = { - {CODING_NAME("fld1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fld1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode153(x64Operand& operand) +asmError x64Parser::Opcode153(x64Operand &operand) { - operand.values[19] = OpcodeCodings153_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings153_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode154(x64Operand& operand) +asmError x64Parser::Opcode154(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6373, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6373, operand); + return rv; } -asmError x64Parser::Opcode155(x64Operand& operand) +asmError x64Parser::Opcode155(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6376, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6376, operand); + return rv; } Coding x64Parser::OpcodeCodings156_19[] = { - {CODING_NAME("fldl2e")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldl2e")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode156(x64Operand& operand) +asmError x64Parser::Opcode156(x64Operand &operand) { - operand.values[19] = OpcodeCodings156_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings156_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings157_19[] = { - {CODING_NAME("fldl2t")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldl2t")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode157(x64Operand& operand) +asmError x64Parser::Opcode157(x64Operand &operand) { - operand.values[19] = OpcodeCodings157_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings157_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings158_19[] = { - {CODING_NAME("fldlg2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldlg2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode158(x64Operand& operand) +asmError x64Parser::Opcode158(x64Operand &operand) { - operand.values[19] = OpcodeCodings158_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings158_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings159_19[] = { - {CODING_NAME("fldln2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldln2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode159(x64Operand& operand) +asmError x64Parser::Opcode159(x64Operand &operand) { - operand.values[19] = OpcodeCodings159_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings159_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings160_19[] = { - {CODING_NAME("fldpi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldpi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode160(x64Operand& operand) +asmError x64Parser::Opcode160(x64Operand &operand) { - operand.values[19] = OpcodeCodings160_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings160_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings161_19[] = { - {CODING_NAME("fldz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fldz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode161(x64Operand& operand) +asmError x64Parser::Opcode161(x64Operand &operand) { - operand.values[19] = OpcodeCodings161_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings161_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings162_18[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings162_39[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings162_36[] = { - {CODING_NAME("fmul")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode162(x64Operand& operand) +asmError x64Parser::Opcode162(x64Operand &operand) { - operand.values[18] = OpcodeCodings162_18; - operand.values[39] = OpcodeCodings162_39; - operand.values[36] = OpcodeCodings162_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings162_18; + operand.values[39] = OpcodeCodings162_39; + operand.values[36] = OpcodeCodings162_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings163_18[] = { - {CODING_NAME("fmulp")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmulp") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings163_19[] = { - {CODING_NAME("fmulp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fmulp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode163(x64Operand& operand) +asmError x64Parser::Opcode163(x64Operand &operand) { - operand.values[18] = OpcodeCodings163_18; - operand.values[19] = OpcodeCodings163_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings163_18; + operand.values[19] = OpcodeCodings163_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings164_19[] = { - {CODING_NAME("fnop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fnop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode164(x64Operand& operand) +asmError x64Parser::Opcode164(x64Operand &operand) { - operand.values[19] = OpcodeCodings164_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings164_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode165(x64Operand& operand) +asmError x64Parser::Opcode165(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6387, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6387, operand); + return rv; } Coding x64Parser::OpcodeCodings166_19[] = { - {CODING_NAME("fpatan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fpatan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode166(x64Operand& operand) +asmError x64Parser::Opcode166(x64Operand &operand) { - operand.values[19] = OpcodeCodings166_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings166_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings167_19[] = { - {CODING_NAME("fprem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fprem")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode167(x64Operand& operand) +asmError x64Parser::Opcode167(x64Operand &operand) { - operand.values[19] = OpcodeCodings167_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings167_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings168_19[] = { - {CODING_NAME("fprem1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fprem1")(Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fprem1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fprem1") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode168(x64Operand& operand) +asmError x64Parser::Opcode168(x64Operand &operand) { - operand.values[19] = OpcodeCodings168_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings168_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings169_19[] = { - {CODING_NAME("fptan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fptan")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode169(x64Operand& operand) +asmError x64Parser::Opcode169(x64Operand &operand) { - operand.values[19] = OpcodeCodings169_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings169_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings170_19[] = { - {CODING_NAME("frndint")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("frndint")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode170(x64Operand& operand) +asmError x64Parser::Opcode170(x64Operand &operand) { - operand.values[19] = OpcodeCodings170_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings170_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode171(x64Operand& operand) +asmError x64Parser::Opcode171(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6394, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6394, operand); + return rv; } -asmError x64Parser::Opcode172(x64Operand& operand) +asmError x64Parser::Opcode172(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6396, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6396, operand); + return rv; } Coding x64Parser::OpcodeCodings173_19[] = { - {CODING_NAME("fscale")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fscale")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode173(x64Operand& operand) +asmError x64Parser::Opcode173(x64Operand &operand) { - operand.values[19] = OpcodeCodings173_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings173_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings174_19[] = { - {CODING_NAME("fsetpm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("fsetpm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode174(x64Operand& operand) +asmError x64Parser::Opcode174(x64Operand &operand) { - operand.values[19] = OpcodeCodings174_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings174_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings175_19[] = { - {CODING_NAME("fsin")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsin")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode175(x64Operand& operand) +asmError x64Parser::Opcode175(x64Operand &operand) { - operand.values[19] = OpcodeCodings175_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings175_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings176_19[] = { - {CODING_NAME("fsincos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsincos")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode176(x64Operand& operand) +asmError x64Parser::Opcode176(x64Operand &operand) { - operand.values[19] = OpcodeCodings176_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings176_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings177_19[] = { - {CODING_NAME("fsqrt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fsqrt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode177(x64Operand& operand) +asmError x64Parser::Opcode177(x64Operand &operand) { - operand.values[19] = OpcodeCodings177_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings177_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode178(x64Operand& operand) +asmError x64Parser::Opcode178(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6403, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6403, operand); + return rv; } -asmError x64Parser::Opcode179(x64Operand& operand) +asmError x64Parser::Opcode179(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6409, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6409, operand); + return rv; } -asmError x64Parser::Opcode180(x64Operand& operand) +asmError x64Parser::Opcode180(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6412, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6412, operand); + return rv; } -asmError x64Parser::Opcode181(x64Operand& operand) +asmError x64Parser::Opcode181(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6415, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6415, operand); + return rv; } -asmError x64Parser::Opcode182(x64Operand& operand) +asmError x64Parser::Opcode182(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6417, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6417, operand); + return rv; } -asmError x64Parser::Opcode183(x64Operand& operand) +asmError x64Parser::Opcode183(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6419, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6419, operand); + return rv; } -asmError x64Parser::Opcode184(x64Operand& operand) +asmError x64Parser::Opcode184(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6427, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6427, operand); + return rv; } -asmError x64Parser::Opcode185(x64Operand& operand) +asmError x64Parser::Opcode185(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6431, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6431, operand); + return rv; } Coding x64Parser::OpcodeCodings186_18[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings186_39[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings186_36[] = { - {CODING_NAME("fsub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode186(x64Operand& operand) +asmError x64Parser::Opcode186(x64Operand &operand) { - operand.values[18] = OpcodeCodings186_18; - operand.values[39] = OpcodeCodings186_39; - operand.values[36] = OpcodeCodings186_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings186_18; + operand.values[39] = OpcodeCodings186_39; + operand.values[36] = OpcodeCodings186_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings187_18[] = { - {CODING_NAME("fsubp")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings187_19[] = { - {CODING_NAME("fsubp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode187(x64Operand& operand) +asmError x64Parser::Opcode187(x64Operand &operand) { - operand.values[18] = OpcodeCodings187_18; - operand.values[19] = OpcodeCodings187_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings187_18; + operand.values[19] = OpcodeCodings187_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings188_18[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings188_39[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings188_36[] = { - {CODING_NAME("fsubr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode188(x64Operand& operand) +asmError x64Parser::Opcode188(x64Operand &operand) { - operand.values[18] = OpcodeCodings188_18; - operand.values[39] = OpcodeCodings188_39; - operand.values[36] = OpcodeCodings188_36; - asmError rv; - { - rv = Opcode8(operand); - } - return rv; + operand.values[18] = OpcodeCodings188_18; + operand.values[39] = OpcodeCodings188_39; + operand.values[36] = OpcodeCodings188_36; + asmError rv; + { + rv = Opcode8(operand); + } + return rv; } Coding x64Parser::OpcodeCodings189_18[] = { - {CODING_NAME("fsubrp")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubrp") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings189_19[] = { - {CODING_NAME("fsubrp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fsubrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode189(x64Operand& operand) +asmError x64Parser::Opcode189(x64Operand &operand) { - operand.values[18] = OpcodeCodings189_18; - operand.values[19] = OpcodeCodings189_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings189_18; + operand.values[19] = OpcodeCodings189_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings190_19[] = { - {CODING_NAME("ftst")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("ftst")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode190(x64Operand& operand) +asmError x64Parser::Opcode190(x64Operand &operand) { - operand.values[19] = OpcodeCodings190_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings190_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings191_18[] = { - {CODING_NAME("fucom")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings191_19[] = { - {CODING_NAME("fucom")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode191(x64Operand& operand) +asmError x64Parser::Opcode191(x64Operand &operand) { - operand.values[18] = OpcodeCodings191_18; - operand.values[19] = OpcodeCodings191_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings191_18; + operand.values[19] = OpcodeCodings191_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings192_18[] = { - {CODING_NAME("fucomi")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomi") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings192_36[] = { - {CODING_NAME("fucomi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode192(x64Operand& operand) +asmError x64Parser::Opcode192(x64Operand &operand) { - operand.values[18] = OpcodeCodings192_18; - operand.values[36] = OpcodeCodings192_36; - asmError rv = ParseOperands(tokenBranches6441, operand); - return rv; + operand.values[18] = OpcodeCodings192_18; + operand.values[36] = OpcodeCodings192_36; + asmError rv = ParseOperands(tokenBranches6441, operand); + return rv; } Coding x64Parser::OpcodeCodings193_18[] = { - {CODING_NAME("fucomip")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomip") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings193_36[] = { - {CODING_NAME("fucomip")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode193(x64Operand& operand) +asmError x64Parser::Opcode193(x64Operand &operand) { - operand.values[18] = OpcodeCodings193_18; - operand.values[36] = OpcodeCodings193_36; - asmError rv = ParseOperands(tokenBranches6445, operand); - return rv; + operand.values[18] = OpcodeCodings193_18; + operand.values[36] = OpcodeCodings193_36; + asmError rv = ParseOperands(tokenBranches6445, operand); + return rv; } Coding x64Parser::OpcodeCodings194_18[] = { - {CODING_NAME("fucomp")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings194_19[] = { - {CODING_NAME("fucomp")(Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode194(x64Operand& operand) +asmError x64Parser::Opcode194(x64Operand &operand) { - operand.values[18] = OpcodeCodings194_18; - operand.values[19] = OpcodeCodings194_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings194_18; + operand.values[19] = OpcodeCodings194_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings195_19[] = { - {CODING_NAME("fucompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("fucompp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode195(x64Operand& operand) +asmError x64Parser::Opcode195(x64Operand &operand) { - operand.values[19] = OpcodeCodings195_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings195_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings196_19[] = { - {CODING_NAME("fwait")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fwait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode196(x64Operand& operand) +asmError x64Parser::Opcode196(x64Operand &operand) { - operand.values[19] = OpcodeCodings196_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings196_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings197_19[] = { - {CODING_NAME("fxam")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fxam")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fxam") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode197(x64Operand& operand) +asmError x64Parser::Opcode197(x64Operand &operand) { - operand.values[19] = OpcodeCodings197_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings197_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings198_18[] = { - {CODING_NAME("fxch")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings198_19[] = { - {CODING_NAME("fxch")(Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode198(x64Operand& operand) +asmError x64Parser::Opcode198(x64Operand &operand) { - operand.values[18] = OpcodeCodings198_18; - operand.values[19] = OpcodeCodings198_19; - asmError rv; - { - rv = Opcode9(operand); - } - return rv; + operand.values[18] = OpcodeCodings198_18; + operand.values[19] = OpcodeCodings198_19; + asmError rv; + { + rv = Opcode9(operand); + } + return rv; } Coding x64Parser::OpcodeCodings199_18[] = { - {CODING_NAME("fxch4")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch4") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings199_36[] = { - {CODING_NAME("fxch4")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch4") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode199(x64Operand& operand) +asmError x64Parser::Opcode199(x64Operand &operand) { - operand.values[18] = OpcodeCodings199_18; - operand.values[36] = OpcodeCodings199_36; - asmError rv = ParseOperands(tokenBranches6454, operand); - return rv; + operand.values[18] = OpcodeCodings199_18; + operand.values[36] = OpcodeCodings199_36; + asmError rv = ParseOperands(tokenBranches6454, operand); + return rv; } Coding x64Parser::OpcodeCodings200_18[] = { - {CODING_NAME("fxch7")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch7") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings200_36[] = { - {CODING_NAME("fxch7")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxch7") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode200(x64Operand& operand) +asmError x64Parser::Opcode200(x64Operand &operand) { - operand.values[18] = OpcodeCodings200_18; - operand.values[36] = OpcodeCodings200_36; - asmError rv = ParseOperands(tokenBranches6458, operand); - return rv; + operand.values[18] = OpcodeCodings200_18; + operand.values[36] = OpcodeCodings200_36; + asmError rv = ParseOperands(tokenBranches6458, operand); + return rv; } -asmError x64Parser::Opcode201(x64Operand& operand) +asmError x64Parser::Opcode201(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6462, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6462, operand); + return rv; } -asmError x64Parser::Opcode202(x64Operand& operand) +asmError x64Parser::Opcode202(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6464, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6464, operand); + return rv; } Coding x64Parser::OpcodeCodings203_19[] = { - {CODING_NAME("fxtract")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fxtract")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode203(x64Operand& operand) +asmError x64Parser::Opcode203(x64Operand &operand) { - operand.values[19] = OpcodeCodings203_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings203_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings204_19[] = { - {CODING_NAME("fyl2x")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fyl2x")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode204(x64Operand& operand) +asmError x64Parser::Opcode204(x64Operand &operand) { - operand.values[19] = OpcodeCodings204_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings204_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings205_19[] = { - {CODING_NAME("fyl2xp1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("fyl2xp1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode205(x64Operand& operand) +asmError x64Parser::Opcode205(x64Operand &operand) { - operand.values[19] = OpcodeCodings205_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings205_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings206_19[] = { - {CODING_NAME("hlt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hlt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode206(x64Operand& operand) +asmError x64Parser::Opcode206(x64Operand &operand) { - operand.values[19] = OpcodeCodings206_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings206_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings207_19[] = { - {CODING_NAME("icebp")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("icebp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode207(x64Operand& operand) +asmError x64Parser::Opcode207(x64Operand &operand) { - operand.values[19] = OpcodeCodings207_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings207_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings208_18[] = { - {CODING_NAME("idiv")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("idiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode208(x64Operand& operand) +asmError x64Parser::Opcode208(x64Operand &operand) { - operand.values[18] = OpcodeCodings208_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings208_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } -asmError x64Parser::Opcode209(x64Operand& operand) +asmError x64Parser::Opcode209(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6472, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6472, operand); + return rv; } -asmError x64Parser::Opcode210(x64Operand& operand) +asmError x64Parser::Opcode210(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6556, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6556, operand); + return rv; } -asmError x64Parser::Opcode211(x64Operand& operand) +asmError x64Parser::Opcode211(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6585, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6585, operand); + return rv; } Coding x64Parser::OpcodeCodings212_19[] = { - {CODING_NAME("insb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode212(x64Operand& operand) +asmError x64Parser::Opcode212(x64Operand &operand) { - operand.values[19] = OpcodeCodings212_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings212_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings213_19[] = { - {CODING_NAME("insw") Coding::stateFunc, 4}, - {CODING_NAME("insw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insw") Coding::stateFunc, 4 }, + { CODING_NAME("insw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode213(x64Operand& operand) +asmError x64Parser::Opcode213(x64Operand &operand) { - operand.values[19] = OpcodeCodings213_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings213_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings214_19[] = { - {CODING_NAME("insd") Coding::stateFunc, 5}, - {CODING_NAME("insd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insd") Coding::stateFunc, 5 }, + { CODING_NAME("insd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode214(x64Operand& operand) +asmError x64Parser::Opcode214(x64Operand &operand) { - operand.values[19] = OpcodeCodings214_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings214_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings215_18[] = { - {CODING_NAME("inc")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings215_19[] = { - {CODING_NAME("inc")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode215(x64Operand& operand) +asmError x64Parser::Opcode215(x64Operand &operand) { - operand.values[18] = OpcodeCodings215_18; - operand.values[19] = OpcodeCodings215_19; - asmError rv; - { - rv = Opcode6(operand); - } - return rv; + operand.values[18] = OpcodeCodings215_18; + operand.values[19] = OpcodeCodings215_19; + asmError rv; + { + rv = Opcode6(operand); + } + return rv; } -asmError x64Parser::Opcode216(x64Operand& operand) +asmError x64Parser::Opcode216(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6728, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6728, operand); + return rv; } Coding x64Parser::OpcodeCodings217_19[] = { - {CODING_NAME("int1")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("int1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode217(x64Operand& operand) +asmError x64Parser::Opcode217(x64Operand &operand) { - operand.values[19] = OpcodeCodings217_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings217_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings218_19[] = { - {CODING_NAME("int3")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("int3") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode218(x64Operand& operand) +asmError x64Parser::Opcode218(x64Operand &operand) { - operand.values[19] = OpcodeCodings218_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings218_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings219_19[] = { - {CODING_NAME("into")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("into") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode219(x64Operand& operand) +asmError x64Parser::Opcode219(x64Operand &operand) { - operand.values[19] = OpcodeCodings219_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings219_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings220_19[] = { - {CODING_NAME("invd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("invd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode220(x64Operand& operand) +asmError x64Parser::Opcode220(x64Operand &operand) { - operand.values[19] = OpcodeCodings220_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings220_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode221(x64Operand& operand) +asmError x64Parser::Opcode221(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6735, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6735, operand); + return rv; } Coding x64Parser::OpcodeCodings222_19[] = { - {CODING_NAME("iret")(Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iret") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode222(x64Operand& operand) +asmError x64Parser::Opcode222(x64Operand &operand) { - operand.values[19] = OpcodeCodings222_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings222_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings223_19[] = { - {CODING_NAME("iretw") Coding::stateFunc, 4}, - {CODING_NAME("iretw")(Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iretw") Coding::stateFunc, 4 }, + { CODING_NAME("iretw") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode223(x64Operand& operand) +asmError x64Parser::Opcode223(x64Operand &operand) { - operand.values[19] = OpcodeCodings223_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings223_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode224(x64Operand& operand) +asmError x64Parser::Opcode224(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6739, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6739, operand); + return rv; } Coding x64Parser::OpcodeCodings225_19[] = { - {CODING_NAME("iretq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("iretq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode225(x64Operand& operand) +asmError x64Parser::Opcode225(x64Operand &operand) { - operand.values[19] = OpcodeCodings225_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings225_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings226_38[] = { - {CODING_NAME("ja")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ja") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode226(x64Operand& operand) +asmError x64Parser::Opcode226(x64Operand &operand) { - operand.values[38] = OpcodeCodings226_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings226_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings227_38[] = { - {CODING_NAME("jae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode227(x64Operand& operand) +asmError x64Parser::Opcode227(x64Operand &operand) { - operand.values[38] = OpcodeCodings227_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings227_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings228_38[] = { - {CODING_NAME("jb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode228(x64Operand& operand) +asmError x64Parser::Opcode228(x64Operand &operand) { - operand.values[38] = OpcodeCodings228_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings228_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings229_38[] = { - {CODING_NAME("jbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode229(x64Operand& operand) +asmError x64Parser::Opcode229(x64Operand &operand) { - operand.values[38] = OpcodeCodings229_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings229_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings230_38[] = { - {CODING_NAME("jc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode230(x64Operand& operand) +asmError x64Parser::Opcode230(x64Operand &operand) { - operand.values[38] = OpcodeCodings230_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings230_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } -asmError x64Parser::Opcode231(x64Operand& operand) +asmError x64Parser::Opcode231(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6747, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6747, operand); + return rv; } -asmError x64Parser::Opcode232(x64Operand& operand) +asmError x64Parser::Opcode232(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6749, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6749, operand); + return rv; } Coding x64Parser::OpcodeCodings233_38[] = { - {CODING_NAME("je")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode233(x64Operand& operand) +asmError x64Parser::Opcode233(x64Operand &operand) { - operand.values[38] = OpcodeCodings233_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings233_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings234_38[] = { - {CODING_NAME("jg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode234(x64Operand& operand) +asmError x64Parser::Opcode234(x64Operand &operand) { - operand.values[38] = OpcodeCodings234_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings234_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings235_38[] = { - {CODING_NAME("jge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode235(x64Operand& operand) +asmError x64Parser::Opcode235(x64Operand &operand) { - operand.values[38] = OpcodeCodings235_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings235_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings236_38[] = { - {CODING_NAME("jl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode236(x64Operand& operand) +asmError x64Parser::Opcode236(x64Operand &operand) { - operand.values[38] = OpcodeCodings236_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings236_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings237_38[] = { - {CODING_NAME("jle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode237(x64Operand& operand) +asmError x64Parser::Opcode237(x64Operand &operand) { - operand.values[38] = OpcodeCodings237_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings237_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } -asmError x64Parser::Opcode238(x64Operand& operand) +asmError x64Parser::Opcode238(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6756, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6756, operand); + return rv; } Coding x64Parser::OpcodeCodings239_38[] = { - {CODING_NAME("jna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode239(x64Operand& operand) +asmError x64Parser::Opcode239(x64Operand &operand) { - operand.values[38] = OpcodeCodings239_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings239_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings240_38[] = { - {CODING_NAME("jnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode240(x64Operand& operand) +asmError x64Parser::Opcode240(x64Operand &operand) { - operand.values[38] = OpcodeCodings240_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings240_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings241_38[] = { - {CODING_NAME("jnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode241(x64Operand& operand) +asmError x64Parser::Opcode241(x64Operand &operand) { - operand.values[38] = OpcodeCodings241_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings241_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings242_38[] = { - {CODING_NAME("jnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode242(x64Operand& operand) +asmError x64Parser::Opcode242(x64Operand &operand) { - operand.values[38] = OpcodeCodings242_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings242_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings243_38[] = { - {CODING_NAME("jnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode243(x64Operand& operand) +asmError x64Parser::Opcode243(x64Operand &operand) { - operand.values[38] = OpcodeCodings243_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings243_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings244_38[] = { - {CODING_NAME("jne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode244(x64Operand& operand) +asmError x64Parser::Opcode244(x64Operand &operand) { - operand.values[38] = OpcodeCodings244_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings244_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings245_38[] = { - {CODING_NAME("jng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode245(x64Operand& operand) +asmError x64Parser::Opcode245(x64Operand &operand) { - operand.values[38] = OpcodeCodings245_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings245_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings246_38[] = { - {CODING_NAME("jnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode246(x64Operand& operand) +asmError x64Parser::Opcode246(x64Operand &operand) { - operand.values[38] = OpcodeCodings246_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings246_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings247_38[] = { - {CODING_NAME("jnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode247(x64Operand& operand) +asmError x64Parser::Opcode247(x64Operand &operand) { - operand.values[38] = OpcodeCodings247_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings247_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings248_38[] = { - {CODING_NAME("jnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode248(x64Operand& operand) +asmError x64Parser::Opcode248(x64Operand &operand) { - operand.values[38] = OpcodeCodings248_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings248_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings249_38[] = { - {CODING_NAME("jno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode249(x64Operand& operand) +asmError x64Parser::Opcode249(x64Operand &operand) { - operand.values[38] = OpcodeCodings249_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings249_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings250_38[] = { - {CODING_NAME("jnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode250(x64Operand& operand) +asmError x64Parser::Opcode250(x64Operand &operand) { - operand.values[38] = OpcodeCodings250_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings250_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings251_38[] = { - {CODING_NAME("jns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode251(x64Operand& operand) +asmError x64Parser::Opcode251(x64Operand &operand) { - operand.values[38] = OpcodeCodings251_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings251_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings252_38[] = { - {CODING_NAME("jnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode252(x64Operand& operand) +asmError x64Parser::Opcode252(x64Operand &operand) { - operand.values[38] = OpcodeCodings252_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings252_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings253_38[] = { - {CODING_NAME("jo")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode253(x64Operand& operand) +asmError x64Parser::Opcode253(x64Operand &operand) { - operand.values[38] = OpcodeCodings253_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings253_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings254_38[] = { - {CODING_NAME("jp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode254(x64Operand& operand) +asmError x64Parser::Opcode254(x64Operand &operand) { - operand.values[38] = OpcodeCodings254_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings254_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings255_38[] = { - {CODING_NAME("jpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode255(x64Operand& operand) +asmError x64Parser::Opcode255(x64Operand &operand) { - operand.values[38] = OpcodeCodings255_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings255_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings256_38[] = { - {CODING_NAME("jpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode256(x64Operand& operand) +asmError x64Parser::Opcode256(x64Operand &operand) { - operand.values[38] = OpcodeCodings256_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings256_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings257_38[] = { - {CODING_NAME("js")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode257(x64Operand& operand) +asmError x64Parser::Opcode257(x64Operand &operand) { - operand.values[38] = OpcodeCodings257_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings257_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings258_38[] = { - {CODING_NAME("jz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode258(x64Operand& operand) +asmError x64Parser::Opcode258(x64Operand &operand) { - operand.values[38] = OpcodeCodings258_38; - asmError rv; - { - rv = Opcode12(operand); - } - return rv; + operand.values[38] = OpcodeCodings258_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; } Coding x64Parser::OpcodeCodings259_19[] = { - {CODING_NAME("lahf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode259(x64Operand& operand) +asmError x64Parser::Opcode259(x64Operand &operand) { - operand.values[19] = OpcodeCodings259_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings259_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings260_36[] = { - {CODING_NAME("lar")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lar")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode260(x64Operand& operand) +asmError x64Parser::Opcode260(x64Operand &operand) { - operand.values[36] = OpcodeCodings260_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings260_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings261_36[] = { - {CODING_NAME("lds") Coding::stateFunc, 7}, - {CODING_NAME("lds")(Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lds") Coding::stateFunc, 7 }, + { CODING_NAME("lds") (Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode261(x64Operand& operand) +asmError x64Parser::Opcode261(x64Operand &operand) { - operand.values[36] = OpcodeCodings261_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings261_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings262_36[] = { - {CODING_NAME("lea")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lea") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode262(x64Operand& operand) +asmError x64Parser::Opcode262(x64Operand &operand) { - operand.values[36] = OpcodeCodings262_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings262_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings263_19[] = { - {CODING_NAME("leave")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("leave") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode263(x64Operand& operand) +asmError x64Parser::Opcode263(x64Operand &operand) { - operand.values[19] = OpcodeCodings263_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings263_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings264_36[] = { - {CODING_NAME("les") Coding::stateFunc, 7}, - {CODING_NAME("les")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("les") Coding::stateFunc, 7 }, + { CODING_NAME("les") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode264(x64Operand& operand) +asmError x64Parser::Opcode264(x64Operand &operand) { - operand.values[36] = OpcodeCodings264_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings264_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings265_19[] = { - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("lfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode265(x64Operand& operand) +asmError x64Parser::Opcode265(x64Operand &operand) { - operand.values[19] = OpcodeCodings265_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings265_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings266_36[] = { - {CODING_NAME("lfs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lfs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode266(x64Operand& operand) +asmError x64Parser::Opcode266(x64Operand &operand) { - operand.values[36] = OpcodeCodings266_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings266_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings267_18[] = { - {CODING_NAME("lgdt")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgdt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings267_19[] = { - {CODING_NAME("lgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode267(x64Operand& operand) +asmError x64Parser::Opcode267(x64Operand &operand) { - operand.values[18] = OpcodeCodings267_18; - operand.values[19] = OpcodeCodings267_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings267_18; + operand.values[19] = OpcodeCodings267_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings268_36[] = { - {CODING_NAME("lgs")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lgs")(Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lgs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lgs") (Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode268(x64Operand& operand) +asmError x64Parser::Opcode268(x64Operand &operand) { - operand.values[36] = OpcodeCodings268_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings268_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings269_18[] = { - {CODING_NAME("lidt")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lidt") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings269_19[] = { - {CODING_NAME("lidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode269(x64Operand& operand) +asmError x64Parser::Opcode269(x64Operand &operand) { - operand.values[18] = OpcodeCodings269_18; - operand.values[19] = OpcodeCodings269_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings269_18; + operand.values[19] = OpcodeCodings269_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings270_18[] = { - {CODING_NAME("lldt")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lldt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings270_19[] = { - {CODING_NAME("lldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode270(x64Operand& operand) +asmError x64Parser::Opcode270(x64Operand &operand) { - operand.values[18] = OpcodeCodings270_18; - operand.values[19] = OpcodeCodings270_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings270_18; + operand.values[19] = OpcodeCodings270_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings271_18[] = { - {CODING_NAME("lmsw")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lmsw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings271_19[] = { - {CODING_NAME("lmsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lmsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode271(x64Operand& operand) +asmError x64Parser::Opcode271(x64Operand &operand) { - operand.values[18] = OpcodeCodings271_18; - operand.values[19] = OpcodeCodings271_19; - asmError rv = ParseOperands(tokenBranches6829, operand); - return rv; + operand.values[18] = OpcodeCodings271_18; + operand.values[19] = OpcodeCodings271_19; + asmError rv = ParseOperands(tokenBranches6829, operand); + return rv; } -asmError x64Parser::Opcode272(x64Operand& operand) +asmError x64Parser::Opcode272(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6831, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6831, operand); + return rv; } Coding x64Parser::OpcodeCodings273_19[] = { - {CODING_NAME("lodsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode273(x64Operand& operand) +asmError x64Parser::Opcode273(x64Operand &operand) { - operand.values[19] = OpcodeCodings273_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings273_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings274_19[] = { - {CODING_NAME("lodsw") Coding::stateFunc, 4}, - {CODING_NAME("lodsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsw") Coding::stateFunc, 4 }, + { CODING_NAME("lodsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode274(x64Operand& operand) +asmError x64Parser::Opcode274(x64Operand &operand) { - operand.values[19] = OpcodeCodings274_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings274_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings275_19[] = { - {CODING_NAME("lodsd") Coding::stateFunc, 5}, - {CODING_NAME("lodsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lodsd") Coding::stateFunc, 5 }, + { CODING_NAME("lodsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode275(x64Operand& operand) +asmError x64Parser::Opcode275(x64Operand &operand) { - operand.values[19] = OpcodeCodings275_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings275_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode276(x64Operand& operand) +asmError x64Parser::Opcode276(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6959, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6959, operand); + return rv; } -asmError x64Parser::Opcode277(x64Operand& operand) +asmError x64Parser::Opcode277(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6961, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6961, operand); + return rv; } -asmError x64Parser::Opcode278(x64Operand& operand) +asmError x64Parser::Opcode278(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6963, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6963, operand); + return rv; } -asmError x64Parser::Opcode279(x64Operand& operand) +asmError x64Parser::Opcode279(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6965, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6965, operand); + return rv; } -asmError x64Parser::Opcode280(x64Operand& operand) +asmError x64Parser::Opcode280(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6967, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6967, operand); + return rv; } -asmError x64Parser::Opcode281(x64Operand& operand) +asmError x64Parser::Opcode281(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6969, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6969, operand); + return rv; } Coding x64Parser::OpcodeCodings282_36[] = { - {CODING_NAME("lsl")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lsl")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode282(x64Operand& operand) +asmError x64Parser::Opcode282(x64Operand &operand) { - operand.values[36] = OpcodeCodings282_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[36] = OpcodeCodings282_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings283_36[] = { - {CODING_NAME("lss") Coding::stateFunc, 7}, - {CODING_NAME("lss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lss") Coding::stateFunc, 7 }, + { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode283(x64Operand& operand) +asmError x64Parser::Opcode283(x64Operand &operand) { - operand.values[36] = OpcodeCodings283_36; - asmError rv; - { - rv = Opcode3(operand); - } - return rv; + operand.values[36] = OpcodeCodings283_36; + asmError rv; + { + rv = Opcode3(operand); + } + return rv; } Coding x64Parser::OpcodeCodings284_18[] = { - {CODING_NAME("ltr")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ltr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings284_19[] = { - {CODING_NAME("ltr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ltr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode284(x64Operand& operand) +asmError x64Parser::Opcode284(x64Operand &operand) { - operand.values[18] = OpcodeCodings284_18; - operand.values[19] = OpcodeCodings284_19; - asmError rv = ParseOperands(tokenBranches6973, operand); - if (rv == AERR_NONE) - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings284_18; + operand.values[19] = OpcodeCodings284_19; + asmError rv = ParseOperands(tokenBranches6973, operand); + if (rv == AERR_NONE) + { + rv = Opcode18(operand); + } + return rv; } -asmError x64Parser::Opcode285(x64Operand& operand) +asmError x64Parser::Opcode285(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6975, operand); - return rv; + asmError rv = ParseOperands(tokenBranches6975, operand); + return rv; } -asmError x64Parser::Opcode286(x64Operand& operand) +asmError x64Parser::Opcode286(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7284, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7284, operand); + return rv; } Coding x64Parser::OpcodeCodings287_36[] = { - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0}, - {CODING_NAME("movbe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, + { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode287(x64Operand& operand) +asmError x64Parser::Opcode287(x64Operand &operand) { - operand.values[36] = OpcodeCodings287_36; - asmError rv = ParseOperands(tokenBranches7547, operand); - return rv; + operand.values[36] = OpcodeCodings287_36; + asmError rv = ParseOperands(tokenBranches7547, operand); + return rv; } Coding x64Parser::OpcodeCodings288_19[] = { - {CODING_NAME("movsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode288(x64Operand& operand) +asmError x64Parser::Opcode288(x64Operand &operand) { - operand.values[19] = OpcodeCodings288_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings288_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings289_19[] = { - {CODING_NAME("movsw") Coding::stateFunc, 4}, - {CODING_NAME("movsw")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsw") Coding::stateFunc, 4 }, + { CODING_NAME("movsw") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode289(x64Operand& operand) +asmError x64Parser::Opcode289(x64Operand &operand) { - operand.values[19] = OpcodeCodings289_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings289_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode290(x64Operand& operand) +asmError x64Parser::Opcode290(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7574, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7574, operand); + return rv; } -asmError x64Parser::Opcode291(x64Operand& operand) +asmError x64Parser::Opcode291(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7582, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7582, operand); + return rv; } Coding x64Parser::OpcodeCodings292_36[] = { - {CODING_NAME("movsx")(Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsx") (Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode292(x64Operand& operand) +asmError x64Parser::Opcode292(x64Operand &operand) { - operand.values[36] = OpcodeCodings292_36; - asmError rv; - { - rv = Opcode15(operand); - } - return rv; + operand.values[36] = OpcodeCodings292_36; + asmError rv; + { + rv = Opcode15(operand); + } + return rv; } Coding x64Parser::OpcodeCodings293_36[] = { - {CODING_NAME("movzx")(Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movzx") (Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode293(x64Operand& operand) +asmError x64Parser::Opcode293(x64Operand &operand) { - operand.values[36] = OpcodeCodings293_36; - asmError rv; - { - rv = Opcode15(operand); - } - return rv; + operand.values[36] = OpcodeCodings293_36; + asmError rv; + { + rv = Opcode15(operand); + } + return rv; } -asmError x64Parser::Opcode294(x64Operand& operand) +asmError x64Parser::Opcode294(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7586, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7586, operand); + return rv; } Coding x64Parser::OpcodeCodings295_18[] = { - {CODING_NAME("mul")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mul") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode295(x64Operand& operand) +asmError x64Parser::Opcode295(x64Operand &operand) { - operand.values[18] = OpcodeCodings295_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings295_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings296_18[] = { - {CODING_NAME("neg")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("neg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode296(x64Operand& operand) +asmError x64Parser::Opcode296(x64Operand &operand) { - operand.values[18] = OpcodeCodings296_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings296_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings297_19[] = { - {CODING_NAME("nop")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("nop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode297(x64Operand& operand) +asmError x64Parser::Opcode297(x64Operand &operand) { - operand.values[19] = OpcodeCodings297_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings297_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings298_18[] = { - {CODING_NAME("not")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("not") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode298(x64Operand& operand) +asmError x64Parser::Opcode298(x64Operand &operand) { - operand.values[18] = OpcodeCodings298_18; - asmError rv; - { - rv = Opcode7(operand); - } - return rv; + operand.values[18] = OpcodeCodings298_18; + asmError rv; + { + rv = Opcode7(operand); + } + return rv; } Coding x64Parser::OpcodeCodings299_18[] = { - {CODING_NAME("or")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings299_36[] = { - {CODING_NAME("or")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings299_37[] = { - {CODING_NAME("or")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode299(x64Operand& operand) +asmError x64Parser::Opcode299(x64Operand &operand) { - operand.values[18] = OpcodeCodings299_18; - operand.values[36] = OpcodeCodings299_36; - operand.values[37] = OpcodeCodings299_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings299_18; + operand.values[36] = OpcodeCodings299_36; + operand.values[37] = OpcodeCodings299_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode300(x64Operand& operand) +asmError x64Parser::Opcode300(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7606, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7606, operand); + return rv; } -asmError x64Parser::Opcode301(x64Operand& operand) +asmError x64Parser::Opcode301(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7635, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7635, operand); + return rv; } Coding x64Parser::OpcodeCodings302_19[] = { - {CODING_NAME("outsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode302(x64Operand& operand) +asmError x64Parser::Opcode302(x64Operand &operand) { - operand.values[19] = OpcodeCodings302_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings302_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings303_19[] = { - {CODING_NAME("outsw") Coding::stateFunc, 4}, - {CODING_NAME("outsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsw") Coding::stateFunc, 4 }, + { CODING_NAME("outsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode303(x64Operand& operand) +asmError x64Parser::Opcode303(x64Operand &operand) { - operand.values[19] = OpcodeCodings303_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings303_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings304_19[] = { - {CODING_NAME("outsd") Coding::stateFunc, 5}, - {CODING_NAME("outsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("outsd") Coding::stateFunc, 5 }, + { CODING_NAME("outsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode304(x64Operand& operand) +asmError x64Parser::Opcode304(x64Operand &operand) { - operand.values[19] = OpcodeCodings304_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings304_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode305(x64Operand& operand) +asmError x64Parser::Opcode305(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7777, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7777, operand); + return rv; } Coding x64Parser::OpcodeCodings306_19[] = { - {CODING_NAME("popa") Coding::stateFunc, 7}, - {CODING_NAME("popa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popa") Coding::stateFunc, 7 }, + { CODING_NAME("popa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode306(x64Operand& operand) +asmError x64Parser::Opcode306(x64Operand &operand) { - operand.values[19] = OpcodeCodings306_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings306_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings307_19[] = { - {CODING_NAME("popaw") Coding::stateFunc, 7}, - {CODING_NAME("popaw") Coding::stateFunc, 4}, - {CODING_NAME("popaw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popaw") Coding::stateFunc, 7 }, + { CODING_NAME("popaw") Coding::stateFunc, 4 }, + { CODING_NAME("popaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode307(x64Operand& operand) +asmError x64Parser::Opcode307(x64Operand &operand) { - operand.values[19] = OpcodeCodings307_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings307_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings308_19[] = { - {CODING_NAME("popad") Coding::stateFunc, 7}, - {CODING_NAME("popad") Coding::stateFunc, 5}, - {CODING_NAME("popad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popad") Coding::stateFunc, 7 }, + { CODING_NAME("popad") Coding::stateFunc, 5 }, + { CODING_NAME("popad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode308(x64Operand& operand) +asmError x64Parser::Opcode308(x64Operand &operand) { - operand.values[19] = OpcodeCodings308_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings308_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings309_23[] = { - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings309_36[] = { - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("popcnt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode309(x64Operand& operand) +asmError x64Parser::Opcode309(x64Operand &operand) { - operand.values[23] = OpcodeCodings309_23; - operand.values[36] = OpcodeCodings309_36; - asmError rv; - { - rv = Opcode2(operand); - } - return rv; + operand.values[23] = OpcodeCodings309_23; + operand.values[36] = OpcodeCodings309_36; + asmError rv; + { + rv = Opcode2(operand); + } + return rv; } Coding x64Parser::OpcodeCodings310_19[] = { - {CODING_NAME("popf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode310(x64Operand& operand) +asmError x64Parser::Opcode310(x64Operand &operand) { - operand.values[19] = OpcodeCodings310_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings310_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings311_19[] = { - {CODING_NAME("popfw") Coding::stateFunc, 4}, - {CODING_NAME("popfw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfw") Coding::stateFunc, 4 }, + { CODING_NAME("popfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode311(x64Operand& operand) +asmError x64Parser::Opcode311(x64Operand &operand) { - operand.values[19] = OpcodeCodings311_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings311_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings312_19[] = { - {CODING_NAME("popfd") Coding::stateFunc, 5}, - {CODING_NAME("popfd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfd") Coding::stateFunc, 5 }, + { CODING_NAME("popfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode312(x64Operand& operand) +asmError x64Parser::Opcode312(x64Operand &operand) { - operand.values[19] = OpcodeCodings312_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings312_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings313_19[] = { - {CODING_NAME("popfq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("popfq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode313(x64Operand& operand) +asmError x64Parser::Opcode313(x64Operand &operand) { - operand.values[19] = OpcodeCodings313_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings313_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode314(x64Operand& operand) +asmError x64Parser::Opcode314(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7798, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7798, operand); + return rv; } -asmError x64Parser::Opcode315(x64Operand& operand) +asmError x64Parser::Opcode315(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7800, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7800, operand); + return rv; } -asmError x64Parser::Opcode316(x64Operand& operand) +asmError x64Parser::Opcode316(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7802, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7802, operand); + return rv; } -asmError x64Parser::Opcode317(x64Operand& operand) +asmError x64Parser::Opcode317(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7804, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7804, operand); + return rv; } -asmError x64Parser::Opcode318(x64Operand& operand) +asmError x64Parser::Opcode318(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7806, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7806, operand); + return rv; } Coding x64Parser::OpcodeCodings319_19[] = { - {CODING_NAME("pusha") Coding::stateFunc, 7}, - {CODING_NAME("pusha")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pusha") Coding::stateFunc, 7 }, + { CODING_NAME("pusha") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode319(x64Operand& operand) +asmError x64Parser::Opcode319(x64Operand &operand) { - operand.values[19] = OpcodeCodings319_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings319_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings320_19[] = { - {CODING_NAME("pushaw") Coding::stateFunc, 7}, - {CODING_NAME("pushaw") Coding::stateFunc, 4}, - {CODING_NAME("pushaw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushaw") Coding::stateFunc, 7 }, + { CODING_NAME("pushaw") Coding::stateFunc, 4 }, + { CODING_NAME("pushaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode320(x64Operand& operand) +asmError x64Parser::Opcode320(x64Operand &operand) { - operand.values[19] = OpcodeCodings320_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings320_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings321_19[] = { - {CODING_NAME("pushad") Coding::stateFunc, 7}, - {CODING_NAME("pushad") Coding::stateFunc, 5}, - {CODING_NAME("pushad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushad") Coding::stateFunc, 7 }, + { CODING_NAME("pushad") Coding::stateFunc, 5 }, + { CODING_NAME("pushad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode321(x64Operand& operand) +asmError x64Parser::Opcode321(x64Operand &operand) { - operand.values[19] = OpcodeCodings321_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings321_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings322_19[] = { - {CODING_NAME("pushf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode322(x64Operand& operand) +asmError x64Parser::Opcode322(x64Operand &operand) { - operand.values[19] = OpcodeCodings322_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings322_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings323_19[] = { - {CODING_NAME("pushfw") Coding::stateFunc, 4}, - {CODING_NAME("pushfw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfw") Coding::stateFunc, 4 }, + { CODING_NAME("pushfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode323(x64Operand& operand) +asmError x64Parser::Opcode323(x64Operand &operand) { - operand.values[19] = OpcodeCodings323_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings323_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings324_19[] = { - {CODING_NAME("pushfd") Coding::stateFunc, 5}, - {CODING_NAME("pushfd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfd") Coding::stateFunc, 5 }, + { CODING_NAME("pushfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode324(x64Operand& operand) +asmError x64Parser::Opcode324(x64Operand &operand) { - operand.values[19] = OpcodeCodings324_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings324_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings325_19[] = { - {CODING_NAME("pushfq")(Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pushfq") (Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode325(x64Operand& operand) +asmError x64Parser::Opcode325(x64Operand &operand) { - operand.values[19] = OpcodeCodings325_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings325_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings326_18[] = { - {CODING_NAME("rcl")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcl") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode326(x64Operand& operand) +asmError x64Parser::Opcode326(x64Operand &operand) { - operand.values[18] = OpcodeCodings326_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings326_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings327_18[] = { - {CODING_NAME("rcr")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode327(x64Operand& operand) +asmError x64Parser::Opcode327(x64Operand &operand) { - operand.values[18] = OpcodeCodings327_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings327_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings328_19[] = { - {CODING_NAME("rdmsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode328(x64Operand& operand) +asmError x64Parser::Opcode328(x64Operand &operand) { - operand.values[19] = OpcodeCodings328_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings328_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings329_19[] = { - {CODING_NAME("rdpmc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdpmc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode329(x64Operand& operand) +asmError x64Parser::Opcode329(x64Operand &operand) { - operand.values[19] = OpcodeCodings329_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings329_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings330_19[] = { - {CODING_NAME("rdtsc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rdtsc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode330(x64Operand& operand) +asmError x64Parser::Opcode330(x64Operand &operand) { - operand.values[19] = OpcodeCodings330_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings330_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode331(x64Operand& operand) +asmError x64Parser::Opcode331(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7842, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7842, operand); + return rv; } -asmError x64Parser::Opcode332(x64Operand& operand) +asmError x64Parser::Opcode332(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7845, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7845, operand); + return rv; } Coding x64Parser::OpcodeCodings333_18[] = { - {CODING_NAME("rol")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rol") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode333(x64Operand& operand) +asmError x64Parser::Opcode333(x64Operand &operand) { - operand.values[18] = OpcodeCodings333_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings333_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings334_18[] = { - {CODING_NAME("ror")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ror") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode334(x64Operand& operand) +asmError x64Parser::Opcode334(x64Operand &operand) { - operand.values[18] = OpcodeCodings334_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings334_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings335_19[] = { - {CODING_NAME("rsm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode335(x64Operand& operand) +asmError x64Parser::Opcode335(x64Operand &operand) { - operand.values[19] = OpcodeCodings335_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings335_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings336_19[] = { - {CODING_NAME("sahf")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode336(x64Operand& operand) +asmError x64Parser::Opcode336(x64Operand &operand) { - operand.values[19] = OpcodeCodings336_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings336_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings337_18[] = { - {CODING_NAME("sal")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sal") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode337(x64Operand& operand) +asmError x64Parser::Opcode337(x64Operand &operand) { - operand.values[18] = OpcodeCodings337_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings337_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings338_18[] = { - {CODING_NAME("sar")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sar") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode338(x64Operand& operand) +asmError x64Parser::Opcode338(x64Operand &operand) { - operand.values[18] = OpcodeCodings338_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings338_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings339_18[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings339_36[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings339_37[] = { - {CODING_NAME("sbb")(Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode339(x64Operand& operand) +asmError x64Parser::Opcode339(x64Operand &operand) { - operand.values[18] = OpcodeCodings339_18; - operand.values[36] = OpcodeCodings339_36; - operand.values[37] = OpcodeCodings339_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings339_18; + operand.values[36] = OpcodeCodings339_36; + operand.values[37] = OpcodeCodings339_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode340(x64Operand& operand) +asmError x64Parser::Opcode340(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7855, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7855, operand); + return rv; } Coding x64Parser::OpcodeCodings341_19[] = { - {CODING_NAME("scasb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode341(x64Operand& operand) +asmError x64Parser::Opcode341(x64Operand &operand) { - operand.values[19] = OpcodeCodings341_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings341_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings342_19[] = { - {CODING_NAME("scasw") Coding::stateFunc, 4}, - {CODING_NAME("scasw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasw") Coding::stateFunc, 4 }, + { CODING_NAME("scasw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode342(x64Operand& operand) +asmError x64Parser::Opcode342(x64Operand &operand) { - operand.values[19] = OpcodeCodings342_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings342_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings343_19[] = { - {CODING_NAME("scasd") Coding::stateFunc, 5}, - {CODING_NAME("scasd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("scasd") Coding::stateFunc, 5 }, + { CODING_NAME("scasd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode343(x64Operand& operand) +asmError x64Parser::Opcode343(x64Operand &operand) { - operand.values[19] = OpcodeCodings343_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings343_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode344(x64Operand& operand) +asmError x64Parser::Opcode344(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7983, operand); - return rv; + asmError rv = ParseOperands(tokenBranches7983, operand); + return rv; } Coding x64Parser::OpcodeCodings345_38[] = { - {CODING_NAME("seta")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode345(x64Operand& operand) +asmError x64Parser::Opcode345(x64Operand &operand) { - operand.values[38] = OpcodeCodings345_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings345_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings346_38[] = { - {CODING_NAME("setae")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode346(x64Operand& operand) +asmError x64Parser::Opcode346(x64Operand &operand) { - operand.values[38] = OpcodeCodings346_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings346_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings347_38[] = { - {CODING_NAME("setb")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode347(x64Operand& operand) +asmError x64Parser::Opcode347(x64Operand &operand) { - operand.values[38] = OpcodeCodings347_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings347_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings348_38[] = { - {CODING_NAME("setbe")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode348(x64Operand& operand) +asmError x64Parser::Opcode348(x64Operand &operand) { - operand.values[38] = OpcodeCodings348_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings348_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings349_38[] = { - {CODING_NAME("setc")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode349(x64Operand& operand) +asmError x64Parser::Opcode349(x64Operand &operand) { - operand.values[38] = OpcodeCodings349_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings349_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings350_38[] = { - {CODING_NAME("sete")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode350(x64Operand& operand) +asmError x64Parser::Opcode350(x64Operand &operand) { - operand.values[38] = OpcodeCodings350_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings350_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings351_38[] = { - {CODING_NAME("setg")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode351(x64Operand& operand) +asmError x64Parser::Opcode351(x64Operand &operand) { - operand.values[38] = OpcodeCodings351_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings351_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings352_38[] = { - {CODING_NAME("setge")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode352(x64Operand& operand) +asmError x64Parser::Opcode352(x64Operand &operand) { - operand.values[38] = OpcodeCodings352_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings352_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings353_38[] = { - {CODING_NAME("setl")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode353(x64Operand& operand) +asmError x64Parser::Opcode353(x64Operand &operand) { - operand.values[38] = OpcodeCodings353_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings353_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings354_38[] = { - {CODING_NAME("setle")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode354(x64Operand& operand) +asmError x64Parser::Opcode354(x64Operand &operand) { - operand.values[38] = OpcodeCodings354_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings354_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings355_38[] = { - {CODING_NAME("setna")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode355(x64Operand& operand) +asmError x64Parser::Opcode355(x64Operand &operand) { - operand.values[38] = OpcodeCodings355_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings355_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings356_38[] = { - {CODING_NAME("setnae")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode356(x64Operand& operand) +asmError x64Parser::Opcode356(x64Operand &operand) { - operand.values[38] = OpcodeCodings356_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings356_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings357_38[] = { - {CODING_NAME("setnb")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode357(x64Operand& operand) +asmError x64Parser::Opcode357(x64Operand &operand) { - operand.values[38] = OpcodeCodings357_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings357_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings358_38[] = { - {CODING_NAME("setnbe")(Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode358(x64Operand& operand) +asmError x64Parser::Opcode358(x64Operand &operand) { - operand.values[38] = OpcodeCodings358_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings358_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings359_38[] = { - {CODING_NAME("setnc")(Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode359(x64Operand& operand) +asmError x64Parser::Opcode359(x64Operand &operand) { - operand.values[38] = OpcodeCodings359_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings359_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings360_38[] = { - {CODING_NAME("setne")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode360(x64Operand& operand) +asmError x64Parser::Opcode360(x64Operand &operand) { - operand.values[38] = OpcodeCodings360_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings360_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings361_38[] = { - {CODING_NAME("setng")(Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode361(x64Operand& operand) +asmError x64Parser::Opcode361(x64Operand &operand) { - operand.values[38] = OpcodeCodings361_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings361_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings362_38[] = { - {CODING_NAME("setnge")(Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode362(x64Operand& operand) +asmError x64Parser::Opcode362(x64Operand &operand) { - operand.values[38] = OpcodeCodings362_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings362_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings363_38[] = { - {CODING_NAME("setnl")(Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode363(x64Operand& operand) +asmError x64Parser::Opcode363(x64Operand &operand) { - operand.values[38] = OpcodeCodings363_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings363_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings364_38[] = { - {CODING_NAME("setnle")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode364(x64Operand& operand) +asmError x64Parser::Opcode364(x64Operand &operand) { - operand.values[38] = OpcodeCodings364_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings364_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings365_38[] = { - {CODING_NAME("setno")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode365(x64Operand& operand) +asmError x64Parser::Opcode365(x64Operand &operand) { - operand.values[38] = OpcodeCodings365_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings365_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings366_38[] = { - {CODING_NAME("setnp")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode366(x64Operand& operand) +asmError x64Parser::Opcode366(x64Operand &operand) { - operand.values[38] = OpcodeCodings366_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings366_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings367_38[] = { - {CODING_NAME("setns")(Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode367(x64Operand& operand) +asmError x64Parser::Opcode367(x64Operand &operand) { - operand.values[38] = OpcodeCodings367_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings367_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings368_38[] = { - {CODING_NAME("setnz")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode368(x64Operand& operand) +asmError x64Parser::Opcode368(x64Operand &operand) { - operand.values[38] = OpcodeCodings368_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings368_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings369_38[] = { - {CODING_NAME("seto")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode369(x64Operand& operand) +asmError x64Parser::Opcode369(x64Operand &operand) { - operand.values[38] = OpcodeCodings369_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings369_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings370_38[] = { - {CODING_NAME("setp")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode370(x64Operand& operand) +asmError x64Parser::Opcode370(x64Operand &operand) { - operand.values[38] = OpcodeCodings370_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings370_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings371_38[] = { - {CODING_NAME("setpe")(Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode371(x64Operand& operand) +asmError x64Parser::Opcode371(x64Operand &operand) { - operand.values[38] = OpcodeCodings371_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings371_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings372_38[] = { - {CODING_NAME("setpo")(Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode372(x64Operand& operand) +asmError x64Parser::Opcode372(x64Operand &operand) { - operand.values[38] = OpcodeCodings372_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings372_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings373_38[] = { - {CODING_NAME("sets")(Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode373(x64Operand& operand) +asmError x64Parser::Opcode373(x64Operand &operand) { - operand.values[38] = OpcodeCodings373_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings373_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings374_38[] = { - {CODING_NAME("setz")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode374(x64Operand& operand) +asmError x64Parser::Opcode374(x64Operand &operand) { - operand.values[38] = OpcodeCodings374_38; - asmError rv; - { - rv = Opcode14(operand); - } - return rv; + operand.values[38] = OpcodeCodings374_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; } Coding x64Parser::OpcodeCodings375_19[] = { - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("sfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode375(x64Operand& operand) +asmError x64Parser::Opcode375(x64Operand &operand) { - operand.values[19] = OpcodeCodings375_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings375_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings376_18[] = { - {CODING_NAME("sgdt")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sgdt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings376_19[] = { - {CODING_NAME("sgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sgdt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode376(x64Operand& operand) +asmError x64Parser::Opcode376(x64Operand &operand) { - operand.values[18] = OpcodeCodings376_18; - operand.values[19] = OpcodeCodings376_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings376_18; + operand.values[19] = OpcodeCodings376_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings377_18[] = { - {CODING_NAME("shl")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shl") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode377(x64Operand& operand) +asmError x64Parser::Opcode377(x64Operand &operand) { - operand.values[18] = OpcodeCodings377_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings377_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings378_36[] = { - {CODING_NAME("shld")(Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shld") (Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode378(x64Operand& operand) +asmError x64Parser::Opcode378(x64Operand &operand) { - operand.values[36] = OpcodeCodings378_36; - asmError rv; - { - rv = Opcode17(operand); - } - return rv; + operand.values[36] = OpcodeCodings378_36; + asmError rv; + { + rv = Opcode17(operand); + } + return rv; } Coding x64Parser::OpcodeCodings379_18[] = { - {CODING_NAME("shr")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode379(x64Operand& operand) +asmError x64Parser::Opcode379(x64Operand &operand) { - operand.values[18] = OpcodeCodings379_18; - asmError rv; - { - rv = Opcode16(operand); - } - return rv; + operand.values[18] = OpcodeCodings379_18; + asmError rv; + { + rv = Opcode16(operand); + } + return rv; } Coding x64Parser::OpcodeCodings380_36[] = { - {CODING_NAME("shrd")(Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shrd") (Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode380(x64Operand& operand) +asmError x64Parser::Opcode380(x64Operand &operand) { - operand.values[36] = OpcodeCodings380_36; - asmError rv; - { - rv = Opcode17(operand); - } - return rv; + operand.values[36] = OpcodeCodings380_36; + asmError rv; + { + rv = Opcode17(operand); + } + return rv; } Coding x64Parser::OpcodeCodings381_18[] = { - {CODING_NAME("sidt")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sidt") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings381_19[] = { - {CODING_NAME("sidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sidt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode381(x64Operand& operand) +asmError x64Parser::Opcode381(x64Operand &operand) { - operand.values[18] = OpcodeCodings381_18; - operand.values[19] = OpcodeCodings381_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings381_18; + operand.values[19] = OpcodeCodings381_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings382_18[] = { - {CODING_NAME("sldt")(Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sldt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings382_19[] = { - {CODING_NAME("sldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sldt")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode382(x64Operand& operand) +asmError x64Parser::Opcode382(x64Operand &operand) { - operand.values[18] = OpcodeCodings382_18; - operand.values[19] = OpcodeCodings382_19; - asmError rv; - { - rv = Opcode18(operand); - } - return rv; + operand.values[18] = OpcodeCodings382_18; + operand.values[19] = OpcodeCodings382_19; + asmError rv; + { + rv = Opcode18(operand); + } + return rv; } Coding x64Parser::OpcodeCodings383_18[] = { - {CODING_NAME("smsw")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("smsw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings383_19[] = { - {CODING_NAME("smsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("smsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode383(x64Operand& operand) +asmError x64Parser::Opcode383(x64Operand &operand) { - operand.values[18] = OpcodeCodings383_18; - operand.values[19] = OpcodeCodings383_19; - asmError rv = ParseOperands(tokenBranches8023, operand); - return rv; + operand.values[18] = OpcodeCodings383_18; + operand.values[19] = OpcodeCodings383_19; + asmError rv = ParseOperands(tokenBranches8023, operand); + return rv; } Coding x64Parser::OpcodeCodings384_19[] = { - {CODING_NAME("stc")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode384(x64Operand& operand) +asmError x64Parser::Opcode384(x64Operand &operand) { - operand.values[19] = OpcodeCodings384_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings384_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings385_19[] = { - {CODING_NAME("std")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("std") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode385(x64Operand& operand) +asmError x64Parser::Opcode385(x64Operand &operand) { - operand.values[19] = OpcodeCodings385_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings385_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings386_19[] = { - {CODING_NAME("sti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode386(x64Operand& operand) +asmError x64Parser::Opcode386(x64Operand &operand) { - operand.values[19] = OpcodeCodings386_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings386_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode387(x64Operand& operand) +asmError x64Parser::Opcode387(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8028, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8028, operand); + return rv; } Coding x64Parser::OpcodeCodings388_19[] = { - {CODING_NAME("stosb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode388(x64Operand& operand) +asmError x64Parser::Opcode388(x64Operand &operand) { - operand.values[19] = OpcodeCodings388_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings388_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings389_19[] = { - {CODING_NAME("stosw") Coding::stateFunc, 4}, - {CODING_NAME("stosw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosw") Coding::stateFunc, 4 }, + { CODING_NAME("stosw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode389(x64Operand& operand) +asmError x64Parser::Opcode389(x64Operand &operand) { - operand.values[19] = OpcodeCodings389_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings389_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings390_19[] = { - {CODING_NAME("stosd") Coding::stateFunc, 5}, - {CODING_NAME("stosd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("stosd") Coding::stateFunc, 5 }, + { CODING_NAME("stosd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode390(x64Operand& operand) +asmError x64Parser::Opcode390(x64Operand &operand) { - operand.values[19] = OpcodeCodings390_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings390_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -asmError x64Parser::Opcode391(x64Operand& operand) +asmError x64Parser::Opcode391(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8156, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8156, operand); + return rv; } Coding x64Parser::OpcodeCodings392_18[] = { - {CODING_NAME("str")(Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("str") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings392_19[] = { - {CODING_NAME("str")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("str")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode392(x64Operand& operand) +asmError x64Parser::Opcode392(x64Operand &operand) { - operand.values[18] = OpcodeCodings392_18; - operand.values[19] = OpcodeCodings392_19; - asmError rv = ParseOperands(tokenBranches8158, operand); - return rv; + operand.values[18] = OpcodeCodings392_18; + operand.values[19] = OpcodeCodings392_19; + asmError rv = ParseOperands(tokenBranches8158, operand); + return rv; } Coding x64Parser::OpcodeCodings393_18[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings393_36[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings393_37[] = { - {CODING_NAME("sub")(Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode393(x64Operand& operand) +asmError x64Parser::Opcode393(x64Operand &operand) { - operand.values[18] = OpcodeCodings393_18; - operand.values[36] = OpcodeCodings393_36; - operand.values[37] = OpcodeCodings393_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings393_18; + operand.values[36] = OpcodeCodings393_36; + operand.values[37] = OpcodeCodings393_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } Coding x64Parser::OpcodeCodings394_19[] = { - {CODING_NAME("syscall")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("syscall") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode394(x64Operand& operand) +asmError x64Parser::Opcode394(x64Operand &operand) { - operand.values[19] = OpcodeCodings394_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings394_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings395_19[] = { - {CODING_NAME("sysenter")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysenter") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode395(x64Operand& operand) +asmError x64Parser::Opcode395(x64Operand &operand) { - operand.values[19] = OpcodeCodings395_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings395_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings396_19[] = { - {CODING_NAME("sysexit")(Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysexit") (Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode396(x64Operand& operand) +asmError x64Parser::Opcode396(x64Operand &operand) { - operand.values[19] = OpcodeCodings396_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings396_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings397_19[] = { - {CODING_NAME("sysret")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sysret") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode397(x64Operand& operand) +asmError x64Parser::Opcode397(x64Operand &operand) { - operand.values[19] = OpcodeCodings397_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings397_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode398(x64Operand& operand) +asmError x64Parser::Opcode398(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8167, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8167, operand); + return rv; } Coding x64Parser::OpcodeCodings399_19[] = { - {CODING_NAME("ud2")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ud2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode399(x64Operand& operand) +asmError x64Parser::Opcode399(x64Operand &operand) { - operand.values[19] = OpcodeCodings399_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings399_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings400_18[] = { - {CODING_NAME("verr")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings400_19[] = { - {CODING_NAME("verr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("verr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode400(x64Operand& operand) +asmError x64Parser::Opcode400(x64Operand &operand) { - operand.values[18] = OpcodeCodings400_18; - operand.values[19] = OpcodeCodings400_19; - asmError rv = ParseOperands(tokenBranches8282, operand); - return rv; + operand.values[18] = OpcodeCodings400_18; + operand.values[19] = OpcodeCodings400_19; + asmError rv = ParseOperands(tokenBranches8282, operand); + return rv; } Coding x64Parser::OpcodeCodings401_18[] = { - {CODING_NAME("verw")(Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verw") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings401_19[] = { - {CODING_NAME("verw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("verw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode401(x64Operand& operand) +asmError x64Parser::Opcode401(x64Operand &operand) { - operand.values[18] = OpcodeCodings401_18; - operand.values[19] = OpcodeCodings401_19; - asmError rv = ParseOperands(tokenBranches8284, operand); - return rv; + operand.values[18] = OpcodeCodings401_18; + operand.values[19] = OpcodeCodings401_19; + asmError rv = ParseOperands(tokenBranches8284, operand); + return rv; } Coding x64Parser::OpcodeCodings402_19[] = { - {CODING_NAME("wait")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode402(x64Operand& operand) +asmError x64Parser::Opcode402(x64Operand &operand) { - operand.values[19] = OpcodeCodings402_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings402_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings403_19[] = { - {CODING_NAME("wbinvd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wbinvd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode403(x64Operand& operand) +asmError x64Parser::Opcode403(x64Operand &operand) { - operand.values[19] = OpcodeCodings403_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings403_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings404_19[] = { - {CODING_NAME("wrmsr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("wrmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode404(x64Operand& operand) +asmError x64Parser::Opcode404(x64Operand &operand) { - operand.values[19] = OpcodeCodings404_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings404_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } -asmError x64Parser::Opcode405(x64Operand& operand) +asmError x64Parser::Opcode405(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8289, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8289, operand); + return rv; } -asmError x64Parser::Opcode406(x64Operand& operand) +asmError x64Parser::Opcode406(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8310, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8310, operand); + return rv; } -asmError x64Parser::Opcode407(x64Operand& operand) +asmError x64Parser::Opcode407(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8369, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8369, operand); + return rv; } Coding x64Parser::OpcodeCodings408_19[] = { - {CODING_NAME("xlatb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xlatb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode408(x64Operand& operand) +asmError x64Parser::Opcode408(x64Operand &operand) { - operand.values[19] = OpcodeCodings408_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings408_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings409_18[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings409_36[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings409_37[] = { - {CODING_NAME("xor")(Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode409(x64Operand& operand) +asmError x64Parser::Opcode409(x64Operand &operand) { - operand.values[18] = OpcodeCodings409_18; - operand.values[36] = OpcodeCodings409_36; - operand.values[37] = OpcodeCodings409_37; - asmError rv; - { - rv = Opcode4(operand); - } - return rv; + operand.values[18] = OpcodeCodings409_18; + operand.values[36] = OpcodeCodings409_36; + operand.values[37] = OpcodeCodings409_37; + asmError rv; + { + rv = Opcode4(operand); + } + return rv; } -asmError x64Parser::Opcode410(x64Operand& operand) +asmError x64Parser::Opcode410(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8409, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8409, operand); + return rv; } -asmError x64Parser::Opcode411(x64Operand& operand) +asmError x64Parser::Opcode411(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8411, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8411, operand); + return rv; } -asmError x64Parser::Opcode412(x64Operand& operand) +asmError x64Parser::Opcode412(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8413, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8413, operand); + return rv; } -asmError x64Parser::Opcode413(x64Operand& operand) +asmError x64Parser::Opcode413(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8415, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8415, operand); + return rv; } Coding x64Parser::OpcodeCodings414_19[] = { - {CODING_NAME("xsetbv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("xsetbv")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode414(x64Operand& operand) +asmError x64Parser::Opcode414(x64Operand &operand) { - operand.values[19] = OpcodeCodings414_19; - asmError rv; - { - rv = Opcode1(operand); - } - return rv; + operand.values[19] = OpcodeCodings414_19; + asmError rv; + { + rv = Opcode1(operand); + } + return rv; } Coding x64Parser::OpcodeCodings415_23[] = { - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings415_19[] = { - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode415(x64Operand& operand) +asmError x64Parser::Opcode415(x64Operand &operand) { - operand.values[23] = OpcodeCodings415_23; - operand.values[19] = OpcodeCodings415_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings415_23; + operand.values[19] = OpcodeCodings415_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings416_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings416_19[] = { - {CODING_NAME("addps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode416(x64Operand& operand) +asmError x64Parser::Opcode416(x64Operand &operand) { - operand.values[23] = OpcodeCodings416_23; - operand.values[19] = OpcodeCodings416_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings416_23; + operand.values[19] = OpcodeCodings416_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings417_23[] = { - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings417_19[] = { - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode417(x64Operand& operand) +asmError x64Parser::Opcode417(x64Operand &operand) { - operand.values[23] = OpcodeCodings417_23; - operand.values[19] = OpcodeCodings417_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings417_23; + operand.values[19] = OpcodeCodings417_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings418_23[] = { - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings418_19[] = { - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode418(x64Operand& operand) +asmError x64Parser::Opcode418(x64Operand &operand) { - operand.values[23] = OpcodeCodings418_23; - operand.values[19] = OpcodeCodings418_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings418_23; + operand.values[19] = OpcodeCodings418_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings419_23[] = { - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings419_19[] = { - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode419(x64Operand& operand) +asmError x64Parser::Opcode419(x64Operand &operand) { - operand.values[23] = OpcodeCodings419_23; - operand.values[19] = OpcodeCodings419_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings419_23; + operand.values[19] = OpcodeCodings419_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings420_23[] = { - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings420_19[] = { - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("addsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode420(x64Operand& operand) +asmError x64Parser::Opcode420(x64Operand &operand) { - operand.values[23] = OpcodeCodings420_23; - operand.values[19] = OpcodeCodings420_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings420_23; + operand.values[19] = OpcodeCodings420_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings421_23[] = { - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings421_19[] = { - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andnpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode421(x64Operand& operand) +asmError x64Parser::Opcode421(x64Operand &operand) { - operand.values[23] = OpcodeCodings421_23; - operand.values[19] = OpcodeCodings421_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings421_23; + operand.values[19] = OpcodeCodings421_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings422_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings422_19[] = { - {CODING_NAME("andnps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andnps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode422(x64Operand& operand) +asmError x64Parser::Opcode422(x64Operand &operand) { - operand.values[23] = OpcodeCodings422_23; - operand.values[19] = OpcodeCodings422_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings422_23; + operand.values[19] = OpcodeCodings422_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings423_23[] = { - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings423_19[] = { - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode423(x64Operand& operand) +asmError x64Parser::Opcode423(x64Operand &operand) { - operand.values[23] = OpcodeCodings423_23; - operand.values[19] = OpcodeCodings423_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings423_23; + operand.values[19] = OpcodeCodings423_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings424_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings424_19[] = { - {CODING_NAME("andps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("andps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode424(x64Operand& operand) +asmError x64Parser::Opcode424(x64Operand &operand) { - operand.values[23] = OpcodeCodings424_23; - operand.values[19] = OpcodeCodings424_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings424_23; + operand.values[19] = OpcodeCodings424_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings425_23[] = { - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings425_19[] = { - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("blendpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode425(x64Operand& operand) +asmError x64Parser::Opcode425(x64Operand &operand) { - operand.values[23] = OpcodeCodings425_23; - operand.values[19] = OpcodeCodings425_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings425_23; + operand.values[19] = OpcodeCodings425_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings426_23[] = { - {CODING_NAME("blendps")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings426_19[] = { - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("blendps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode426(x64Operand& operand) +asmError x64Parser::Opcode426(x64Operand &operand) { - operand.values[23] = OpcodeCodings426_23; - operand.values[19] = OpcodeCodings426_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings426_23; + operand.values[19] = OpcodeCodings426_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings427_23[] = { - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings427_19[] = { - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode427(x64Operand& operand) +asmError x64Parser::Opcode427(x64Operand &operand) { - operand.values[23] = OpcodeCodings427_23; - operand.values[19] = OpcodeCodings427_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings427_23; + operand.values[19] = OpcodeCodings427_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings428_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings428_19[] = { - {CODING_NAME("cmpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cmpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode428(x64Operand& operand) +asmError x64Parser::Opcode428(x64Operand &operand) { - operand.values[23] = OpcodeCodings428_23; - operand.values[19] = OpcodeCodings428_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings428_23; + operand.values[19] = OpcodeCodings428_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings429_23[] = { - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings429_19[] = { - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("comisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode429(x64Operand& operand) +asmError x64Parser::Opcode429(x64Operand &operand) { - operand.values[23] = OpcodeCodings429_23; - operand.values[19] = OpcodeCodings429_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings429_23; + operand.values[19] = OpcodeCodings429_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings430_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings430_19[] = { - {CODING_NAME("comiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("comiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode430(x64Operand& operand) +asmError x64Parser::Opcode430(x64Operand &operand) { - operand.values[23] = OpcodeCodings430_23; - operand.values[19] = OpcodeCodings430_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings430_23; + operand.values[19] = OpcodeCodings430_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings431_23[] = { - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings431_19[] = { - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtdq2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode431(x64Operand& operand) +asmError x64Parser::Opcode431(x64Operand &operand) { - operand.values[23] = OpcodeCodings431_23; - operand.values[19] = OpcodeCodings431_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings431_23; + operand.values[19] = OpcodeCodings431_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings432_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings432_19[] = { - {CODING_NAME("cvtdq2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtdq2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode432(x64Operand& operand) +asmError x64Parser::Opcode432(x64Operand &operand) { - operand.values[23] = OpcodeCodings432_23; - operand.values[19] = OpcodeCodings432_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings432_23; + operand.values[19] = OpcodeCodings432_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings433_23[] = { - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings433_19[] = { - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode433(x64Operand& operand) +asmError x64Parser::Opcode433(x64Operand &operand) { - operand.values[23] = OpcodeCodings433_23; - operand.values[19] = OpcodeCodings433_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings433_23; + operand.values[19] = OpcodeCodings433_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings434_23[] = { - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings434_19[] = { - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode434(x64Operand& operand) +asmError x64Parser::Opcode434(x64Operand &operand) { - operand.values[23] = OpcodeCodings434_23; - operand.values[19] = OpcodeCodings434_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings434_23; + operand.values[19] = OpcodeCodings434_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings435_23[] = { - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings435_19[] = { - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpd2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode435(x64Operand& operand) +asmError x64Parser::Opcode435(x64Operand &operand) { - operand.values[23] = OpcodeCodings435_23; - operand.values[19] = OpcodeCodings435_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings435_23; + operand.values[19] = OpcodeCodings435_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings436_23[] = { - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings436_19[] = { - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpi2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode436(x64Operand& operand) +asmError x64Parser::Opcode436(x64Operand &operand) { - operand.values[23] = OpcodeCodings436_23; - operand.values[19] = OpcodeCodings436_19; - asmError rv; - { - rv = Opcode24(operand); - } - return rv; + operand.values[23] = OpcodeCodings436_23; + operand.values[19] = OpcodeCodings436_19; + asmError rv; + { + rv = Opcode24(operand); + } + return rv; } Coding x64Parser::OpcodeCodings437_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings437_19[] = { - {CODING_NAME("cvtpi2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtpi2ps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode437(x64Operand& operand) +asmError x64Parser::Opcode437(x64Operand &operand) { - operand.values[23] = OpcodeCodings437_23; - operand.values[19] = OpcodeCodings437_19; - asmError rv; - { - rv = Opcode24(operand); - } - return rv; + operand.values[23] = OpcodeCodings437_23; + operand.values[19] = OpcodeCodings437_19; + asmError rv; + { + rv = Opcode24(operand); + } + return rv; } Coding x64Parser::OpcodeCodings438_23[] = { - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings438_19[] = { - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode438(x64Operand& operand) +asmError x64Parser::Opcode438(x64Operand &operand) { - operand.values[23] = OpcodeCodings438_23; - operand.values[19] = OpcodeCodings438_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings438_23; + operand.values[19] = OpcodeCodings438_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings439_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings439_19[] = { - {CODING_NAME("cvtps2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2pd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode439(x64Operand& operand) +asmError x64Parser::Opcode439(x64Operand &operand) { - operand.values[23] = OpcodeCodings439_23; - operand.values[19] = OpcodeCodings439_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings439_23; + operand.values[19] = OpcodeCodings439_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings440_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings440_19[] = { - {CODING_NAME("cvtps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode440(x64Operand& operand) +asmError x64Parser::Opcode440(x64Operand &operand) { - operand.values[23] = OpcodeCodings440_23; - operand.values[19] = OpcodeCodings440_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings440_23; + operand.values[19] = OpcodeCodings440_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings441_23[] = { - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings441_19[] = { - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode441(x64Operand& operand) +asmError x64Parser::Opcode441(x64Operand &operand) { - operand.values[23] = OpcodeCodings441_23; - operand.values[19] = OpcodeCodings441_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings441_23; + operand.values[19] = OpcodeCodings441_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings442_23[] = { - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings442_19[] = { - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsd2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode442(x64Operand& operand) +asmError x64Parser::Opcode442(x64Operand &operand) { - operand.values[23] = OpcodeCodings442_23; - operand.values[19] = OpcodeCodings442_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings442_23; + operand.values[19] = OpcodeCodings442_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings443_23[] = { - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings443_19[] = { - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsi2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode443(x64Operand& operand) +asmError x64Parser::Opcode443(x64Operand &operand) { - operand.values[23] = OpcodeCodings443_23; - operand.values[19] = OpcodeCodings443_19; - asmError rv; - { - rv = Opcode26(operand); - } - return rv; + operand.values[23] = OpcodeCodings443_23; + operand.values[19] = OpcodeCodings443_19; + asmError rv; + { + rv = Opcode26(operand); + } + return rv; } Coding x64Parser::OpcodeCodings444_23[] = { - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings444_19[] = { - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtsi2ss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode444(x64Operand& operand) +asmError x64Parser::Opcode444(x64Operand &operand) { - operand.values[23] = OpcodeCodings444_23; - operand.values[19] = OpcodeCodings444_19; - asmError rv; - { - rv = Opcode26(operand); - } - return rv; + operand.values[23] = OpcodeCodings444_23; + operand.values[19] = OpcodeCodings444_19; + asmError rv; + { + rv = Opcode26(operand); + } + return rv; } Coding x64Parser::OpcodeCodings445_23[] = { - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings445_19[] = { - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtss2sd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode445(x64Operand& operand) +asmError x64Parser::Opcode445(x64Operand &operand) { - operand.values[23] = OpcodeCodings445_23; - operand.values[19] = OpcodeCodings445_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings445_23; + operand.values[19] = OpcodeCodings445_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings446_23[] = { - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings446_19[] = { - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvtss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode446(x64Operand& operand) +asmError x64Parser::Opcode446(x64Operand &operand) { - operand.values[23] = OpcodeCodings446_23; - operand.values[19] = OpcodeCodings446_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings446_23; + operand.values[19] = OpcodeCodings446_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings447_23[] = { - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings447_19[] = { - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttpd2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode447(x64Operand& operand) +asmError x64Parser::Opcode447(x64Operand &operand) { - operand.values[23] = OpcodeCodings447_23; - operand.values[19] = OpcodeCodings447_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings447_23; + operand.values[19] = OpcodeCodings447_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings448_23[] = { - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings448_19[] = { - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttpd2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode448(x64Operand& operand) +asmError x64Parser::Opcode448(x64Operand &operand) { - operand.values[23] = OpcodeCodings448_23; - operand.values[19] = OpcodeCodings448_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings448_23; + operand.values[19] = OpcodeCodings448_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings449_23[] = { - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings449_19[] = { - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttps2dq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode449(x64Operand& operand) +asmError x64Parser::Opcode449(x64Operand &operand) { - operand.values[23] = OpcodeCodings449_23; - operand.values[19] = OpcodeCodings449_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings449_23; + operand.values[19] = OpcodeCodings449_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings450_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings450_19[] = { - {CODING_NAME("cvttps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttps2pi")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode450(x64Operand& operand) +asmError x64Parser::Opcode450(x64Operand &operand) { - operand.values[23] = OpcodeCodings450_23; - operand.values[19] = OpcodeCodings450_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings450_23; + operand.values[19] = OpcodeCodings450_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings451_23[] = { - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings451_19[] = { - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttsd2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode451(x64Operand& operand) +asmError x64Parser::Opcode451(x64Operand &operand) { - operand.values[23] = OpcodeCodings451_23; - operand.values[19] = OpcodeCodings451_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings451_23; + operand.values[19] = OpcodeCodings451_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings452_23[] = { - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings452_19[] = { - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("cvttss2si")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode452(x64Operand& operand) +asmError x64Parser::Opcode452(x64Operand &operand) { - operand.values[23] = OpcodeCodings452_23; - operand.values[19] = OpcodeCodings452_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings452_23; + operand.values[19] = OpcodeCodings452_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings453_23[] = { - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings453_19[] = { - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode453(x64Operand& operand) +asmError x64Parser::Opcode453(x64Operand &operand) { - operand.values[23] = OpcodeCodings453_23; - operand.values[19] = OpcodeCodings453_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings453_23; + operand.values[19] = OpcodeCodings453_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings454_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings454_19[] = { - {CODING_NAME("divps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode454(x64Operand& operand) +asmError x64Parser::Opcode454(x64Operand &operand) { - operand.values[23] = OpcodeCodings454_23; - operand.values[19] = OpcodeCodings454_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings454_23; + operand.values[19] = OpcodeCodings454_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings455_23[] = { - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings455_19[] = { - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode455(x64Operand& operand) +asmError x64Parser::Opcode455(x64Operand &operand) { - operand.values[23] = OpcodeCodings455_23; - operand.values[19] = OpcodeCodings455_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings455_23; + operand.values[19] = OpcodeCodings455_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings456_23[] = { - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings456_19[] = { - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("divss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode456(x64Operand& operand) +asmError x64Parser::Opcode456(x64Operand &operand) { - operand.values[23] = OpcodeCodings456_23; - operand.values[19] = OpcodeCodings456_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings456_23; + operand.values[19] = OpcodeCodings456_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings457_23[] = { - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings457_19[] = { - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("dppd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode457(x64Operand& operand) +asmError x64Parser::Opcode457(x64Operand &operand) { - operand.values[23] = OpcodeCodings457_23; - operand.values[19] = OpcodeCodings457_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings457_23; + operand.values[19] = OpcodeCodings457_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings458_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings458_19[] = { - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("dpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode458(x64Operand& operand) +asmError x64Parser::Opcode458(x64Operand &operand) { - operand.values[23] = OpcodeCodings458_23; - operand.values[19] = OpcodeCodings458_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings458_23; + operand.values[19] = OpcodeCodings458_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings459_23[] = { - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings459_19[] = { - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("hsubpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode459(x64Operand& operand) +asmError x64Parser::Opcode459(x64Operand &operand) { - operand.values[23] = OpcodeCodings459_23; - operand.values[19] = OpcodeCodings459_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings459_23; + operand.values[19] = OpcodeCodings459_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings460_23[] = { - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings460_19[] = { - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("hsubps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode460(x64Operand& operand) +asmError x64Parser::Opcode460(x64Operand &operand) { - operand.values[23] = OpcodeCodings460_23; - operand.values[19] = OpcodeCodings460_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings460_23; + operand.values[19] = OpcodeCodings460_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings461_23[] = { - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings461_19[] = { - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("insertps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode461(x64Operand& operand) +asmError x64Parser::Opcode461(x64Operand &operand) { - operand.values[23] = OpcodeCodings461_23; - operand.values[19] = OpcodeCodings461_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings461_23; + operand.values[19] = OpcodeCodings461_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings462_23[] = { - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings462_19[] = { - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("lddqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode462(x64Operand& operand) +asmError x64Parser::Opcode462(x64Operand &operand) { - operand.values[23] = OpcodeCodings462_23; - operand.values[19] = OpcodeCodings462_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings462_23; + operand.values[19] = OpcodeCodings462_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } -asmError x64Parser::Opcode463(x64Operand& operand) +asmError x64Parser::Opcode463(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8466, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8466, operand); + return rv; } -asmError x64Parser::Opcode464(x64Operand& operand) +asmError x64Parser::Opcode464(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8470, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8470, operand); + return rv; } Coding x64Parser::OpcodeCodings465_23[] = { - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings465_19[] = { - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode465(x64Operand& operand) +asmError x64Parser::Opcode465(x64Operand &operand) { - operand.values[23] = OpcodeCodings465_23; - operand.values[19] = OpcodeCodings465_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings465_23; + operand.values[19] = OpcodeCodings465_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings466_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings466_19[] = { - {CODING_NAME("maxps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode466(x64Operand& operand) +asmError x64Parser::Opcode466(x64Operand &operand) { - operand.values[23] = OpcodeCodings466_23; - operand.values[19] = OpcodeCodings466_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings466_23; + operand.values[19] = OpcodeCodings466_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings467_23[] = { - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings467_19[] = { - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode467(x64Operand& operand) +asmError x64Parser::Opcode467(x64Operand &operand) { - operand.values[23] = OpcodeCodings467_23; - operand.values[19] = OpcodeCodings467_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings467_23; + operand.values[19] = OpcodeCodings467_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings468_23[] = { - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings468_19[] = { - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("maxss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode468(x64Operand& operand) +asmError x64Parser::Opcode468(x64Operand &operand) { - operand.values[23] = OpcodeCodings468_23; - operand.values[19] = OpcodeCodings468_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings468_23; + operand.values[19] = OpcodeCodings468_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings469_19[] = { - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("mfence")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode469(x64Operand& operand) +asmError x64Parser::Opcode469(x64Operand &operand) { - operand.values[19] = OpcodeCodings469_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings469_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } -Coding x64Parser::OpcodeCodings470_23[] = { - {CODING_NAME("eot") Coding::eot}, -}; Coding x64Parser::OpcodeCodings470_19[] = { - {CODING_NAME("pause")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("pause")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode470(x64Operand& operand) +asmError x64Parser::Opcode470(x64Operand &operand) { - operand.values[23] = OpcodeCodings470_23; - operand.values[19] = OpcodeCodings470_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings470_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings471_23[] = { - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings471_19[] = { - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode471(x64Operand& operand) +asmError x64Parser::Opcode471(x64Operand &operand) { - operand.values[23] = OpcodeCodings471_23; - operand.values[19] = OpcodeCodings471_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings471_23; + operand.values[19] = OpcodeCodings471_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings472_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings472_19[] = { - {CODING_NAME("minps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode472(x64Operand& operand) +asmError x64Parser::Opcode472(x64Operand &operand) { - operand.values[23] = OpcodeCodings472_23; - operand.values[19] = OpcodeCodings472_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings472_23; + operand.values[19] = OpcodeCodings472_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings473_23[] = { - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings473_19[] = { - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode473(x64Operand& operand) +asmError x64Parser::Opcode473(x64Operand &operand) { - operand.values[23] = OpcodeCodings473_23; - operand.values[19] = OpcodeCodings473_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings473_23; + operand.values[19] = OpcodeCodings473_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings474_23[] = { - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings474_19[] = { - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("minss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode474(x64Operand& operand) +asmError x64Parser::Opcode474(x64Operand &operand) { - operand.values[23] = OpcodeCodings474_23; - operand.values[19] = OpcodeCodings474_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings474_23; + operand.values[19] = OpcodeCodings474_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings475_19[] = { - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("monitor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode475(x64Operand& operand) +asmError x64Parser::Opcode475(x64Operand &operand) { - operand.values[19] = OpcodeCodings475_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; + operand.values[19] = OpcodeCodings475_19; + asmError rv; + { + rv = Opcode0(operand); + } + return rv; } Coding x64Parser::OpcodeCodings476_23[] = { - {CODING_NAME("movapd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movapd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings476_36[] = { - {CODING_NAME("movapd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movapd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode476(x64Operand& operand) +asmError x64Parser::Opcode476(x64Operand &operand) { - operand.values[23] = OpcodeCodings476_23; - operand.values[36] = OpcodeCodings476_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings476_23; + operand.values[36] = OpcodeCodings476_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings477_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings477_36[] = { - {CODING_NAME("movaps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movaps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode477(x64Operand& operand) +asmError x64Parser::Opcode477(x64Operand &operand) { - operand.values[23] = OpcodeCodings477_23; - operand.values[36] = OpcodeCodings477_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings477_23; + operand.values[36] = OpcodeCodings477_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } -asmError x64Parser::Opcode478(x64Operand& operand) +asmError x64Parser::Opcode478(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8487, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8487, operand); + return rv; } -asmError x64Parser::Opcode479(x64Operand& operand) +asmError x64Parser::Opcode479(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8500, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8500, operand); + return rv; } Coding x64Parser::OpcodeCodings480_23[] = { - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings480_19[] = { - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movddup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode480(x64Operand& operand) +asmError x64Parser::Opcode480(x64Operand &operand) { - operand.values[23] = OpcodeCodings480_23; - operand.values[19] = OpcodeCodings480_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings480_23; + operand.values[19] = OpcodeCodings480_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings481_23[] = { - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings481_19[] = { - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movdq2q")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode481(x64Operand& operand) +asmError x64Parser::Opcode481(x64Operand &operand) { - operand.values[23] = OpcodeCodings481_23; - operand.values[19] = OpcodeCodings481_19; - asmError rv; - { - rv = Opcode23(operand); - } - return rv; + operand.values[23] = OpcodeCodings481_23; + operand.values[19] = OpcodeCodings481_19; + asmError rv; + { + rv = Opcode23(operand); + } + return rv; } Coding x64Parser::OpcodeCodings482_23[] = { - {CODING_NAME("movdqa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings482_36[] = { - {CODING_NAME("movdqa")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode482(x64Operand& operand) +asmError x64Parser::Opcode482(x64Operand &operand) { - operand.values[23] = OpcodeCodings482_23; - operand.values[36] = OpcodeCodings482_36; - asmError rv; - { - rv = Opcode21(operand); - } - return rv; + operand.values[23] = OpcodeCodings482_23; + operand.values[36] = OpcodeCodings482_36; + asmError rv; + { + rv = Opcode21(operand); + } + return rv; } Coding x64Parser::OpcodeCodings483_23[] = { - {CODING_NAME("movdqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings483_36[] = { - {CODING_NAME("movdqu")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode483(x64Operand& operand) +asmError x64Parser::Opcode483(x64Operand &operand) { - operand.values[23] = OpcodeCodings483_23; - operand.values[36] = OpcodeCodings483_36; - asmError rv; - { - rv = Opcode21(operand); - } - return rv; + operand.values[23] = OpcodeCodings483_23; + operand.values[36] = OpcodeCodings483_36; + asmError rv; + { + rv = Opcode21(operand); + } + return rv; } -asmError x64Parser::Opcode484(x64Operand& operand) +asmError x64Parser::Opcode484(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8529, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8529, operand); + return rv; } Coding x64Parser::OpcodeCodings485_23[] = { - {CODING_NAME("movhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings485_36[] = { - {CODING_NAME("movhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode485(x64Operand& operand) +asmError x64Parser::Opcode485(x64Operand &operand) { - operand.values[23] = OpcodeCodings485_23; - operand.values[36] = OpcodeCodings485_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings485_23; + operand.values[36] = OpcodeCodings485_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings486_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings486_36[] = { - {CODING_NAME("movhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode486(x64Operand& operand) +asmError x64Parser::Opcode486(x64Operand &operand) { - operand.values[23] = OpcodeCodings486_23; - operand.values[36] = OpcodeCodings486_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings486_23; + operand.values[36] = OpcodeCodings486_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } -asmError x64Parser::Opcode487(x64Operand& operand) +asmError x64Parser::Opcode487(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8535, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8535, operand); + return rv; } Coding x64Parser::OpcodeCodings488_23[] = { - {CODING_NAME("movlpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings488_36[] = { - {CODING_NAME("movlpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode488(x64Operand& operand) +asmError x64Parser::Opcode488(x64Operand &operand) { - operand.values[23] = OpcodeCodings488_23; - operand.values[36] = OpcodeCodings488_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings488_23; + operand.values[36] = OpcodeCodings488_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings489_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings489_36[] = { - {CODING_NAME("movlps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movlps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode489(x64Operand& operand) +asmError x64Parser::Opcode489(x64Operand &operand) { - operand.values[23] = OpcodeCodings489_23; - operand.values[36] = OpcodeCodings489_36; - asmError rv; - { - rv = Opcode22(operand); - } - return rv; + operand.values[23] = OpcodeCodings489_23; + operand.values[36] = OpcodeCodings489_36; + asmError rv; + { + rv = Opcode22(operand); + } + return rv; } Coding x64Parser::OpcodeCodings490_23[] = { - {CODING_NAME("movmskpd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings490_19[] = { - {CODING_NAME("movmskpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movmskpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode490(x64Operand& operand) +asmError x64Parser::Opcode490(x64Operand &operand) { - operand.values[23] = OpcodeCodings490_23; - operand.values[19] = OpcodeCodings490_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings490_23; + operand.values[19] = OpcodeCodings490_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } Coding x64Parser::OpcodeCodings491_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings491_19[] = { - {CODING_NAME("movmskps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movmskps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode491(x64Operand& operand) +asmError x64Parser::Opcode491(x64Operand &operand) { - operand.values[23] = OpcodeCodings491_23; - operand.values[19] = OpcodeCodings491_19; - asmError rv; - { - rv = Opcode25(operand); - } - return rv; + operand.values[23] = OpcodeCodings491_23; + operand.values[19] = OpcodeCodings491_19; + asmError rv; + { + rv = Opcode25(operand); + } + return rv; } -asmError x64Parser::Opcode492(x64Operand& operand) +asmError x64Parser::Opcode492(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8543, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8543, operand); + return rv; } Coding x64Parser::OpcodeCodings493_19[] = { - {CODING_NAME("movnti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movnti")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode493(x64Operand& operand) +asmError x64Parser::Opcode493(x64Operand &operand) { - operand.values[19] = OpcodeCodings493_19; - asmError rv = ParseOperands(tokenBranches8547, operand); - return rv; + operand.values[19] = OpcodeCodings493_19; + asmError rv = ParseOperands(tokenBranches8547, operand); + return rv; } -asmError x64Parser::Opcode494(x64Operand& operand) +asmError x64Parser::Opcode494(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8554, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8554, operand); + return rv; } -asmError x64Parser::Opcode495(x64Operand& operand) +asmError x64Parser::Opcode495(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8558, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8558, operand); + return rv; } -asmError x64Parser::Opcode496(x64Operand& operand) +asmError x64Parser::Opcode496(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8562, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8562, operand); + return rv; } -asmError x64Parser::Opcode497(x64Operand& operand) +asmError x64Parser::Opcode497(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8566, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8566, operand); + return rv; } Coding x64Parser::OpcodeCodings498_23[] = { - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings498_19[] = { - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movshdup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode498(x64Operand& operand) +asmError x64Parser::Opcode498(x64Operand &operand) { - operand.values[23] = OpcodeCodings498_23; - operand.values[19] = OpcodeCodings498_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings498_23; + operand.values[19] = OpcodeCodings498_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings499_23[] = { - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings499_19[] = { - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("movsldup")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode499(x64Operand& operand) +asmError x64Parser::Opcode499(x64Operand &operand) { - operand.values[23] = OpcodeCodings499_23; - operand.values[19] = OpcodeCodings499_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings499_23; + operand.values[19] = OpcodeCodings499_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings500_23[] = { - {CODING_NAME("movss")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movss") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings500_36[] = { - {CODING_NAME("movss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode500(x64Operand& operand) +asmError x64Parser::Opcode500(x64Operand &operand) { - operand.values[23] = OpcodeCodings500_23; - operand.values[36] = OpcodeCodings500_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings500_23; + operand.values[36] = OpcodeCodings500_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings501_23[] = { - {CODING_NAME("movupd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movupd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings501_36[] = { - {CODING_NAME("movupd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movupd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode501(x64Operand& operand) +asmError x64Parser::Opcode501(x64Operand &operand) { - operand.values[23] = OpcodeCodings501_23; - operand.values[36] = OpcodeCodings501_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings501_23; + operand.values[36] = OpcodeCodings501_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings502_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings502_36[] = { - {CODING_NAME("movups")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("movups") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode502(x64Operand& operand) +asmError x64Parser::Opcode502(x64Operand &operand) { - operand.values[23] = OpcodeCodings502_23; - operand.values[36] = OpcodeCodings502_36; - asmError rv; - { - rv = Opcode20(operand); - } - return rv; + operand.values[23] = OpcodeCodings502_23; + operand.values[36] = OpcodeCodings502_36; + asmError rv; + { + rv = Opcode20(operand); + } + return rv; } Coding x64Parser::OpcodeCodings503_23[] = { - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings503_19[] = { - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("mpsadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode503(x64Operand& operand) +asmError x64Parser::Opcode503(x64Operand &operand) { - operand.values[23] = OpcodeCodings503_23; - operand.values[19] = OpcodeCodings503_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings503_23; + operand.values[19] = OpcodeCodings503_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings504_23[] = { - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings504_19[] = { - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode504(x64Operand& operand) +asmError x64Parser::Opcode504(x64Operand &operand) { - operand.values[23] = OpcodeCodings504_23; - operand.values[19] = OpcodeCodings504_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings504_23; + operand.values[19] = OpcodeCodings504_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings505_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings505_19[] = { - {CODING_NAME("mulps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode505(x64Operand& operand) +asmError x64Parser::Opcode505(x64Operand &operand) { - operand.values[23] = OpcodeCodings505_23; - operand.values[19] = OpcodeCodings505_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings505_23; + operand.values[19] = OpcodeCodings505_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings506_23[] = { - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings506_19[] = { - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode506(x64Operand& operand) +asmError x64Parser::Opcode506(x64Operand &operand) { - operand.values[23] = OpcodeCodings506_23; - operand.values[19] = OpcodeCodings506_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings506_23; + operand.values[19] = OpcodeCodings506_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings507_23[] = { - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings507_19[] = { - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("mulss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode507(x64Operand& operand) +asmError x64Parser::Opcode507(x64Operand &operand) { - operand.values[23] = OpcodeCodings507_23; - operand.values[19] = OpcodeCodings507_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings507_23; + operand.values[19] = OpcodeCodings507_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings508_23[] = { - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings508_19[] = { - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("orpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode508(x64Operand& operand) +asmError x64Parser::Opcode508(x64Operand &operand) { - operand.values[23] = OpcodeCodings508_23; - operand.values[19] = OpcodeCodings508_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings508_23; + operand.values[19] = OpcodeCodings508_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings509_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings509_19[] = { - {CODING_NAME("orps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("orps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode509(x64Operand& operand) +asmError x64Parser::Opcode509(x64Operand &operand) { - operand.values[23] = OpcodeCodings509_23; - operand.values[19] = OpcodeCodings509_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings509_23; + operand.values[19] = OpcodeCodings509_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings510_19[] = { - {CODING_NAME("packssdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packssdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode510(x64Operand& operand) +asmError x64Parser::Opcode510(x64Operand &operand) { - operand.values[19] = OpcodeCodings510_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings510_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings511_19[] = { - {CODING_NAME("packsswb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packsswb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode511(x64Operand& operand) +asmError x64Parser::Opcode511(x64Operand &operand) { - operand.values[19] = OpcodeCodings511_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings511_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings512_23[] = { - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings512_19[] = { - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0}, - {CODING_NAME("packusdw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, + { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode512(x64Operand& operand) +asmError x64Parser::Opcode512(x64Operand &operand) { - operand.values[23] = OpcodeCodings512_23; - operand.values[19] = OpcodeCodings512_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings512_23; + operand.values[19] = OpcodeCodings512_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings513_19[] = { - {CODING_NAME("paddb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode513(x64Operand& operand) +asmError x64Parser::Opcode513(x64Operand &operand) { - operand.values[19] = OpcodeCodings513_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings513_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings514_19[] = { - {CODING_NAME("paddd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode514(x64Operand& operand) +asmError x64Parser::Opcode514(x64Operand &operand) { - operand.values[19] = OpcodeCodings514_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings514_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings515_19[] = { - {CODING_NAME("paddq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode515(x64Operand& operand) +asmError x64Parser::Opcode515(x64Operand &operand) { - operand.values[19] = OpcodeCodings515_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings515_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings516_19[] = { - {CODING_NAME("paddsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode516(x64Operand& operand) +asmError x64Parser::Opcode516(x64Operand &operand) { - operand.values[19] = OpcodeCodings516_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings516_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings517_19[] = { - {CODING_NAME("paddusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode517(x64Operand& operand) +asmError x64Parser::Opcode517(x64Operand &operand) { - operand.values[19] = OpcodeCodings517_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings517_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings518_19[] = { - {CODING_NAME("paddusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode518(x64Operand& operand) +asmError x64Parser::Opcode518(x64Operand &operand) { - operand.values[19] = OpcodeCodings518_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings518_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings519_19[] = { - {CODING_NAME("paddw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("paddw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode519(x64Operand& operand) +asmError x64Parser::Opcode519(x64Operand &operand) { - operand.values[19] = OpcodeCodings519_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings519_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings520_19[] = { - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("palignr")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode520(x64Operand& operand) +asmError x64Parser::Opcode520(x64Operand &operand) { - operand.values[19] = OpcodeCodings520_19; - asmError rv = ParseOperands(tokenBranches8592, operand); - return rv; + operand.values[19] = OpcodeCodings520_19; + asmError rv = ParseOperands(tokenBranches8592, operand); + return rv; } Coding x64Parser::OpcodeCodings521_19[] = { - {CODING_NAME("pand")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pand")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode521(x64Operand& operand) +asmError x64Parser::Opcode521(x64Operand &operand) { - operand.values[19] = OpcodeCodings521_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings521_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings522_19[] = { - {CODING_NAME("pandn")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pandn")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode522(x64Operand& operand) +asmError x64Parser::Opcode522(x64Operand &operand) { - operand.values[19] = OpcodeCodings522_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings522_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings523_19[] = { - {CODING_NAME("pavgb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pavgb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode523(x64Operand& operand) +asmError x64Parser::Opcode523(x64Operand &operand) { - operand.values[19] = OpcodeCodings523_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings523_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings524_19[] = { - {CODING_NAME("pavgw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pavgw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode524(x64Operand& operand) +asmError x64Parser::Opcode524(x64Operand &operand) { - operand.values[19] = OpcodeCodings524_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings524_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings525_23[] = { - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings525_19[] = { - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pblendw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode525(x64Operand& operand) +asmError x64Parser::Opcode525(x64Operand &operand) { - operand.values[23] = OpcodeCodings525_23; - operand.values[19] = OpcodeCodings525_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings525_23; + operand.values[19] = OpcodeCodings525_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings526_19[] = { - {CODING_NAME("pcmpeqb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode526(x64Operand& operand) +asmError x64Parser::Opcode526(x64Operand &operand) { - operand.values[19] = OpcodeCodings526_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings526_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings527_19[] = { - {CODING_NAME("pcmpeqd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode527(x64Operand& operand) +asmError x64Parser::Opcode527(x64Operand &operand) { - operand.values[19] = OpcodeCodings527_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings527_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings528_19[] = { - {CODING_NAME("pcmpeqw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpeqw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode528(x64Operand& operand) +asmError x64Parser::Opcode528(x64Operand &operand) { - operand.values[19] = OpcodeCodings528_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings528_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings529_23[] = { - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings529_19[] = { - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pcmpestri")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode529(x64Operand& operand) +asmError x64Parser::Opcode529(x64Operand &operand) { - operand.values[23] = OpcodeCodings529_23; - operand.values[19] = OpcodeCodings529_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings529_23; + operand.values[19] = OpcodeCodings529_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings530_23[] = { - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings530_19[] = { - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pcmpestrm")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode530(x64Operand& operand) +asmError x64Parser::Opcode530(x64Operand &operand) { - operand.values[23] = OpcodeCodings530_23; - operand.values[19] = OpcodeCodings530_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings530_23; + operand.values[19] = OpcodeCodings530_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings531_19[] = { - {CODING_NAME("pcmpgtb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode531(x64Operand& operand) +asmError x64Parser::Opcode531(x64Operand &operand) { - operand.values[19] = OpcodeCodings531_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings531_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings532_19[] = { - {CODING_NAME("pcmpgtd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode532(x64Operand& operand) +asmError x64Parser::Opcode532(x64Operand &operand) { - operand.values[19] = OpcodeCodings532_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings532_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings533_19[] = { - {CODING_NAME("pcmpgtw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pcmpgtw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode533(x64Operand& operand) +asmError x64Parser::Opcode533(x64Operand &operand) { - operand.values[19] = OpcodeCodings533_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings533_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings534_19[] = { - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode534(x64Operand& operand) +asmError x64Parser::Opcode534(x64Operand &operand) { - operand.values[19] = OpcodeCodings534_19; - asmError rv = ParseOperands(tokenBranches8616, operand); - return rv; + operand.values[19] = OpcodeCodings534_19; + asmError rv = ParseOperands(tokenBranches8616, operand); + return rv; } Coding x64Parser::OpcodeCodings535_19[] = { - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode535(x64Operand& operand) +asmError x64Parser::Opcode535(x64Operand &operand) { - operand.values[19] = OpcodeCodings535_19; - asmError rv = ParseOperands(tokenBranches8622, operand); - return rv; + operand.values[19] = OpcodeCodings535_19; + asmError rv = ParseOperands(tokenBranches8622, operand); + return rv; } Coding x64Parser::OpcodeCodings536_19[] = { - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pextrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode536(x64Operand& operand) +asmError x64Parser::Opcode536(x64Operand &operand) { - operand.values[19] = OpcodeCodings536_19; - asmError rv = ParseOperands(tokenBranches8628, operand); - return rv; + operand.values[19] = OpcodeCodings536_19; + asmError rv = ParseOperands(tokenBranches8628, operand); + return rv; } -asmError x64Parser::Opcode537(x64Operand& operand) +asmError x64Parser::Opcode537(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8634, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8634, operand); + return rv; } Coding x64Parser::OpcodeCodings538_19[] = { - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode538(x64Operand& operand) +asmError x64Parser::Opcode538(x64Operand &operand) { - operand.values[19] = OpcodeCodings538_19; - asmError rv = ParseOperands(tokenBranches8655, operand); - return rv; + operand.values[19] = OpcodeCodings538_19; + asmError rv = ParseOperands(tokenBranches8655, operand); + return rv; } Coding x64Parser::OpcodeCodings539_19[] = { - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode539(x64Operand& operand) +asmError x64Parser::Opcode539(x64Operand &operand) { - operand.values[19] = OpcodeCodings539_19; - asmError rv = ParseOperands(tokenBranches8661, operand); - return rv; + operand.values[19] = OpcodeCodings539_19; + asmError rv = ParseOperands(tokenBranches8661, operand); + return rv; } Coding x64Parser::OpcodeCodings540_19[] = { - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("pinsrq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode540(x64Operand& operand) +asmError x64Parser::Opcode540(x64Operand &operand) { - operand.values[19] = OpcodeCodings540_19; - asmError rv = ParseOperands(tokenBranches8667, operand); - return rv; + operand.values[19] = OpcodeCodings540_19; + asmError rv = ParseOperands(tokenBranches8667, operand); + return rv; } -asmError x64Parser::Opcode541(x64Operand& operand) +asmError x64Parser::Opcode541(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8673, operand); - return rv; + asmError rv = ParseOperands(tokenBranches8673, operand); + return rv; } Coding x64Parser::OpcodeCodings542_19[] = { - {CODING_NAME("pmaddwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaddwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode542(x64Operand& operand) +asmError x64Parser::Opcode542(x64Operand &operand) { - operand.values[19] = OpcodeCodings542_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings542_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings543_19[] = { - {CODING_NAME("pmaxsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaxsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode543(x64Operand& operand) +asmError x64Parser::Opcode543(x64Operand &operand) { - operand.values[19] = OpcodeCodings543_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings543_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings544_19[] = { - {CODING_NAME("pmaxub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmaxub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode544(x64Operand& operand) +asmError x64Parser::Opcode544(x64Operand &operand) { - operand.values[19] = OpcodeCodings544_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings544_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings545_19[] = { - {CODING_NAME("pminsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pminsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode545(x64Operand& operand) +asmError x64Parser::Opcode545(x64Operand &operand) { - operand.values[19] = OpcodeCodings545_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings545_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings546_19[] = { - {CODING_NAME("pminub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pminub")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode546(x64Operand& operand) +asmError x64Parser::Opcode546(x64Operand &operand) { - operand.values[19] = OpcodeCodings546_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings546_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings547_19[] = { - {CODING_NAME("pmovmskb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmovmskb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode547(x64Operand& operand) +asmError x64Parser::Opcode547(x64Operand &operand) { - operand.values[19] = OpcodeCodings547_19; - asmError rv = ParseOperands(tokenBranches8699, operand); - return rv; + operand.values[19] = OpcodeCodings547_19; + asmError rv = ParseOperands(tokenBranches8699, operand); + return rv; } Coding x64Parser::OpcodeCodings548_19[] = { - {CODING_NAME("pmulhuw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmulhuw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode548(x64Operand& operand) +asmError x64Parser::Opcode548(x64Operand &operand) { - operand.values[19] = OpcodeCodings548_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings548_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings549_19[] = { - {CODING_NAME("pmulhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmulhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode549(x64Operand& operand) +asmError x64Parser::Opcode549(x64Operand &operand) { - operand.values[19] = OpcodeCodings549_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings549_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings550_19[] = { - {CODING_NAME("pmullw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmullw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode550(x64Operand& operand) +asmError x64Parser::Opcode550(x64Operand &operand) { - operand.values[19] = OpcodeCodings550_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings550_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings551_19[] = { - {CODING_NAME("pmuludq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pmuludq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode551(x64Operand& operand) +asmError x64Parser::Opcode551(x64Operand &operand) { - operand.values[19] = OpcodeCodings551_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings551_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings552_19[] = { - {CODING_NAME("psadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psadbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode552(x64Operand& operand) +asmError x64Parser::Opcode552(x64Operand &operand) { - operand.values[19] = OpcodeCodings552_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings552_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings553_23[] = { - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings553_19[] = { - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode553(x64Operand& operand) +asmError x64Parser::Opcode553(x64Operand &operand) { - operand.values[23] = OpcodeCodings553_23; - operand.values[19] = OpcodeCodings553_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings553_23; + operand.values[19] = OpcodeCodings553_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings554_23[] = { - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings554_19[] = { - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufhw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode554(x64Operand& operand) +asmError x64Parser::Opcode554(x64Operand &operand) { - operand.values[23] = OpcodeCodings554_23; - operand.values[19] = OpcodeCodings554_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings554_23; + operand.values[19] = OpcodeCodings554_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings555_23[] = { - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings555_19[] = { - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshuflw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode555(x64Operand& operand) +asmError x64Parser::Opcode555(x64Operand &operand) { - operand.values[23] = OpcodeCodings555_23; - operand.values[19] = OpcodeCodings555_19; - asmError rv; - { - rv = Opcode28(operand); - } - return rv; + operand.values[23] = OpcodeCodings555_23; + operand.values[19] = OpcodeCodings555_19; + asmError rv; + { + rv = Opcode28(operand); + } + return rv; } Coding x64Parser::OpcodeCodings556_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings556_19[] = { - {CODING_NAME("pshufw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pshufw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode556(x64Operand& operand) +asmError x64Parser::Opcode556(x64Operand &operand) { - operand.values[23] = OpcodeCodings556_23; - operand.values[19] = OpcodeCodings556_19; - asmError rv = ParseOperands(tokenBranches8720, operand); - return rv; + operand.values[23] = OpcodeCodings556_23; + operand.values[19] = OpcodeCodings556_19; + asmError rv = ParseOperands(tokenBranches8720, operand); + return rv; } Coding x64Parser::OpcodeCodings557_39[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings557_36[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings557_37[] = { - {CODING_NAME("pslld")(Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode557(x64Operand& operand) +asmError x64Parser::Opcode557(x64Operand &operand) { - operand.values[39] = OpcodeCodings557_39; - operand.values[36] = OpcodeCodings557_36; - operand.values[37] = OpcodeCodings557_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings557_39; + operand.values[36] = OpcodeCodings557_36; + operand.values[37] = OpcodeCodings557_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings558_23[] = { - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings558_19[] = { - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pslldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode558(x64Operand& operand) +asmError x64Parser::Opcode558(x64Operand &operand) { - operand.values[23] = OpcodeCodings558_23; - operand.values[19] = OpcodeCodings558_19; - asmError rv = ParseOperands(tokenBranches8727, operand); - return rv; + operand.values[23] = OpcodeCodings558_23; + operand.values[19] = OpcodeCodings558_19; + asmError rv = ParseOperands(tokenBranches8727, operand); + return rv; } Coding x64Parser::OpcodeCodings559_39[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_36[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_37[] = { - {CODING_NAME("psllq")(Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode559(x64Operand& operand) +asmError x64Parser::Opcode559(x64Operand &operand) { - operand.values[39] = OpcodeCodings559_39; - operand.values[36] = OpcodeCodings559_36; - operand.values[37] = OpcodeCodings559_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings559_39; + operand.values[36] = OpcodeCodings559_36; + operand.values[37] = OpcodeCodings559_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings560_39[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings560_36[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings560_37[] = { - {CODING_NAME("psllw")(Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode560(x64Operand& operand) +asmError x64Parser::Opcode560(x64Operand &operand) { - operand.values[39] = OpcodeCodings560_39; - operand.values[36] = OpcodeCodings560_36; - operand.values[37] = OpcodeCodings560_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings560_39; + operand.values[36] = OpcodeCodings560_36; + operand.values[37] = OpcodeCodings560_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings561_39[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_36[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_37[] = { - {CODING_NAME("psrad")(Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode561(x64Operand& operand) +asmError x64Parser::Opcode561(x64Operand &operand) { - operand.values[39] = OpcodeCodings561_39; - operand.values[36] = OpcodeCodings561_36; - operand.values[37] = OpcodeCodings561_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings561_39; + operand.values[36] = OpcodeCodings561_36; + operand.values[37] = OpcodeCodings561_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings562_39[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_36[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_37[] = { - {CODING_NAME("psraw")(Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode562(x64Operand& operand) +asmError x64Parser::Opcode562(x64Operand &operand) { - operand.values[39] = OpcodeCodings562_39; - operand.values[36] = OpcodeCodings562_36; - operand.values[37] = OpcodeCodings562_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings562_39; + operand.values[36] = OpcodeCodings562_36; + operand.values[37] = OpcodeCodings562_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings563_39[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_36[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_37[] = { - {CODING_NAME("psrld")(Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode563(x64Operand& operand) +asmError x64Parser::Opcode563(x64Operand &operand) { - operand.values[39] = OpcodeCodings563_39; - operand.values[36] = OpcodeCodings563_36; - operand.values[37] = OpcodeCodings563_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings563_39; + operand.values[36] = OpcodeCodings563_36; + operand.values[37] = OpcodeCodings563_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings564_23[] = { - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings564_19[] = { - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psrldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode564(x64Operand& operand) +asmError x64Parser::Opcode564(x64Operand &operand) { - operand.values[23] = OpcodeCodings564_23; - operand.values[19] = OpcodeCodings564_19; - asmError rv = ParseOperands(tokenBranches8736, operand); - return rv; + operand.values[23] = OpcodeCodings564_23; + operand.values[19] = OpcodeCodings564_19; + asmError rv = ParseOperands(tokenBranches8736, operand); + return rv; } Coding x64Parser::OpcodeCodings565_39[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_36[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_37[] = { - {CODING_NAME("psrlq")(Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode565(x64Operand& operand) +asmError x64Parser::Opcode565(x64Operand &operand) { - operand.values[39] = OpcodeCodings565_39; - operand.values[36] = OpcodeCodings565_36; - operand.values[37] = OpcodeCodings565_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings565_39; + operand.values[36] = OpcodeCodings565_36; + operand.values[37] = OpcodeCodings565_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings566_39[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings566_36[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings566_37[] = { - {CODING_NAME("psrlw")(Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode566(x64Operand& operand) +asmError x64Parser::Opcode566(x64Operand &operand) { - operand.values[39] = OpcodeCodings566_39; - operand.values[36] = OpcodeCodings566_36; - operand.values[37] = OpcodeCodings566_37; - asmError rv; - { - rv = Opcode29(operand); - } - return rv; + operand.values[39] = OpcodeCodings566_39; + operand.values[36] = OpcodeCodings566_36; + operand.values[37] = OpcodeCodings566_37; + asmError rv; + { + rv = Opcode29(operand); + } + return rv; } Coding x64Parser::OpcodeCodings567_19[] = { - {CODING_NAME("psubb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode567(x64Operand& operand) +asmError x64Parser::Opcode567(x64Operand &operand) { - operand.values[19] = OpcodeCodings567_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings567_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings568_19[] = { - {CODING_NAME("psubd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode568(x64Operand& operand) +asmError x64Parser::Opcode568(x64Operand &operand) { - operand.values[19] = OpcodeCodings568_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings568_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings569_19[] = { - {CODING_NAME("psubq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode569(x64Operand& operand) +asmError x64Parser::Opcode569(x64Operand &operand) { - operand.values[19] = OpcodeCodings569_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings569_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings570_19[] = { - {CODING_NAME("psubsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubsb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode570(x64Operand& operand) +asmError x64Parser::Opcode570(x64Operand &operand) { - operand.values[19] = OpcodeCodings570_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings570_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings571_19[] = { - {CODING_NAME("psubsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubsw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode571(x64Operand& operand) +asmError x64Parser::Opcode571(x64Operand &operand) { - operand.values[19] = OpcodeCodings571_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings571_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings572_19[] = { - {CODING_NAME("psubusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubusb")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode572(x64Operand& operand) +asmError x64Parser::Opcode572(x64Operand &operand) { - operand.values[19] = OpcodeCodings572_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings572_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings573_19[] = { - {CODING_NAME("psubusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("psubusw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode573(x64Operand& operand) +asmError x64Parser::Opcode573(x64Operand &operand) { - operand.values[19] = OpcodeCodings573_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings573_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings574_19[] = { - {CODING_NAME("punpckhbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode574(x64Operand& operand) +asmError x64Parser::Opcode574(x64Operand &operand) { - operand.values[19] = OpcodeCodings574_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings574_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings575_19[] = { - {CODING_NAME("punpckhdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode575(x64Operand& operand) +asmError x64Parser::Opcode575(x64Operand &operand) { - operand.values[19] = OpcodeCodings575_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings575_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings576_23[] = { - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings576_19[] = { - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode576(x64Operand& operand) +asmError x64Parser::Opcode576(x64Operand &operand) { - operand.values[23] = OpcodeCodings576_23; - operand.values[19] = OpcodeCodings576_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings576_23; + operand.values[19] = OpcodeCodings576_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings577_19[] = { - {CODING_NAME("punpckhwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckhwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode577(x64Operand& operand) +asmError x64Parser::Opcode577(x64Operand &operand) { - operand.values[19] = OpcodeCodings577_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings577_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings578_19[] = { - {CODING_NAME("punpcklbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklbw")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode578(x64Operand& operand) +asmError x64Parser::Opcode578(x64Operand &operand) { - operand.values[19] = OpcodeCodings578_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings578_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings579_19[] = { - {CODING_NAME("punpckldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpckldq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode579(x64Operand& operand) +asmError x64Parser::Opcode579(x64Operand &operand) { - operand.values[19] = OpcodeCodings579_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings579_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings580_23[] = { - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings580_19[] = { - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklqdq")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode580(x64Operand& operand) +asmError x64Parser::Opcode580(x64Operand &operand) { - operand.values[23] = OpcodeCodings580_23; - operand.values[19] = OpcodeCodings580_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings580_23; + operand.values[19] = OpcodeCodings580_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings581_19[] = { - {CODING_NAME("punpcklwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("punpcklwd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode581(x64Operand& operand) +asmError x64Parser::Opcode581(x64Operand &operand) { - operand.values[19] = OpcodeCodings581_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings581_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings582_19[] = { - {CODING_NAME("pxor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("pxor")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode582(x64Operand& operand) +asmError x64Parser::Opcode582(x64Operand &operand) { - operand.values[19] = OpcodeCodings582_19; - asmError rv; - { - rv = Opcode27(operand); - } - return rv; + operand.values[19] = OpcodeCodings582_19; + asmError rv; + { + rv = Opcode27(operand); + } + return rv; } Coding x64Parser::OpcodeCodings583_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings583_19[] = { - {CODING_NAME("rcpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rcpps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode583(x64Operand& operand) +asmError x64Parser::Opcode583(x64Operand &operand) { - operand.values[23] = OpcodeCodings583_23; - operand.values[19] = OpcodeCodings583_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings583_23; + operand.values[19] = OpcodeCodings583_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings584_23[] = { - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings584_19[] = { - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rcpss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode584(x64Operand& operand) +asmError x64Parser::Opcode584(x64Operand &operand) { - operand.values[23] = OpcodeCodings584_23; - operand.values[19] = OpcodeCodings584_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings584_23; + operand.values[19] = OpcodeCodings584_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings585_23[] = { - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings585_19[] = { - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode585(x64Operand& operand) +asmError x64Parser::Opcode585(x64Operand &operand) { - operand.values[23] = OpcodeCodings585_23; - operand.values[19] = OpcodeCodings585_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings585_23; + operand.values[19] = OpcodeCodings585_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings586_23[] = { - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings586_19[] = { - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode586(x64Operand& operand) +asmError x64Parser::Opcode586(x64Operand &operand) { - operand.values[23] = OpcodeCodings586_23; - operand.values[19] = OpcodeCodings586_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings586_23; + operand.values[19] = OpcodeCodings586_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings587_23[] = { - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings587_19[] = { - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode587(x64Operand& operand) +asmError x64Parser::Opcode587(x64Operand &operand) { - operand.values[23] = OpcodeCodings587_23; - operand.values[19] = OpcodeCodings587_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings587_23; + operand.values[19] = OpcodeCodings587_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings588_23[] = { - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings588_19[] = { - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0}, - {CODING_NAME("roundss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode588(x64Operand& operand) +asmError x64Parser::Opcode588(x64Operand &operand) { - operand.values[23] = OpcodeCodings588_23; - operand.values[19] = OpcodeCodings588_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings588_23; + operand.values[19] = OpcodeCodings588_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings589_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings589_19[] = { - {CODING_NAME("rsqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rsqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode589(x64Operand& operand) +asmError x64Parser::Opcode589(x64Operand &operand) { - operand.values[23] = OpcodeCodings589_23; - operand.values[19] = OpcodeCodings589_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings589_23; + operand.values[19] = OpcodeCodings589_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings590_23[] = { - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings590_19[] = { - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("rsqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode590(x64Operand& operand) +asmError x64Parser::Opcode590(x64Operand &operand) { - operand.values[23] = OpcodeCodings590_23; - operand.values[19] = OpcodeCodings590_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings590_23; + operand.values[19] = OpcodeCodings590_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings591_23[] = { - {CODING_NAME("shufpd")(Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings591_19[] = { - {CODING_NAME("shufpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("shufpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode591(x64Operand& operand) +asmError x64Parser::Opcode591(x64Operand &operand) { - operand.values[23] = OpcodeCodings591_23; - operand.values[19] = OpcodeCodings591_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings591_23; + operand.values[19] = OpcodeCodings591_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings592_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings592_19[] = { - {CODING_NAME("shufps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("shufps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode592(x64Operand& operand) +asmError x64Parser::Opcode592(x64Operand &operand) { - operand.values[23] = OpcodeCodings592_23; - operand.values[19] = OpcodeCodings592_19; - asmError rv; - { - rv = Opcode30(operand); - } - return rv; + operand.values[23] = OpcodeCodings592_23; + operand.values[19] = OpcodeCodings592_19; + asmError rv; + { + rv = Opcode30(operand); + } + return rv; } Coding x64Parser::OpcodeCodings593_23[] = { - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings593_19[] = { - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode593(x64Operand& operand) +asmError x64Parser::Opcode593(x64Operand &operand) { - operand.values[23] = OpcodeCodings593_23; - operand.values[19] = OpcodeCodings593_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings593_23; + operand.values[19] = OpcodeCodings593_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings594_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings594_19[] = { - {CODING_NAME("sqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode594(x64Operand& operand) +asmError x64Parser::Opcode594(x64Operand &operand) { - operand.values[23] = OpcodeCodings594_23; - operand.values[19] = OpcodeCodings594_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings594_23; + operand.values[19] = OpcodeCodings594_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings595_23[] = { - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings595_19[] = { - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode595(x64Operand& operand) +asmError x64Parser::Opcode595(x64Operand &operand) { - operand.values[23] = OpcodeCodings595_23; - operand.values[19] = OpcodeCodings595_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings595_23; + operand.values[19] = OpcodeCodings595_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings596_23[] = { - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings596_19[] = { - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("sqrtss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode596(x64Operand& operand) +asmError x64Parser::Opcode596(x64Operand &operand) { - operand.values[23] = OpcodeCodings596_23; - operand.values[19] = OpcodeCodings596_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings596_23; + operand.values[19] = OpcodeCodings596_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings597_23[] = { - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings597_19[] = { - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode597(x64Operand& operand) +asmError x64Parser::Opcode597(x64Operand &operand) { - operand.values[23] = OpcodeCodings597_23; - operand.values[19] = OpcodeCodings597_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings597_23; + operand.values[19] = OpcodeCodings597_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings598_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings598_19[] = { - {CODING_NAME("subps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode598(x64Operand& operand) +asmError x64Parser::Opcode598(x64Operand &operand) { - operand.values[23] = OpcodeCodings598_23; - operand.values[19] = OpcodeCodings598_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings598_23; + operand.values[19] = OpcodeCodings598_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings599_23[] = { - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings599_19[] = { - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subsd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode599(x64Operand& operand) +asmError x64Parser::Opcode599(x64Operand &operand) { - operand.values[23] = OpcodeCodings599_23; - operand.values[19] = OpcodeCodings599_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings599_23; + operand.values[19] = OpcodeCodings599_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings600_23[] = { - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings600_19[] = { - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("subss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode600(x64Operand& operand) +asmError x64Parser::Opcode600(x64Operand &operand) { - operand.values[23] = OpcodeCodings600_23; - operand.values[19] = OpcodeCodings600_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings600_23; + operand.values[19] = OpcodeCodings600_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings601_23[] = { - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings601_19[] = { - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ucomisd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode601(x64Operand& operand) +asmError x64Parser::Opcode601(x64Operand &operand) { - operand.values[23] = OpcodeCodings601_23; - operand.values[19] = OpcodeCodings601_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings601_23; + operand.values[19] = OpcodeCodings601_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings602_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings602_19[] = { - {CODING_NAME("ucomiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("ucomiss")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode602(x64Operand& operand) +asmError x64Parser::Opcode602(x64Operand &operand) { - operand.values[23] = OpcodeCodings602_23; - operand.values[19] = OpcodeCodings602_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings602_23; + operand.values[19] = OpcodeCodings602_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings603_23[] = { - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings603_19[] = { - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpckhpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode603(x64Operand& operand) +asmError x64Parser::Opcode603(x64Operand &operand) { - operand.values[23] = OpcodeCodings603_23; - operand.values[19] = OpcodeCodings603_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings603_23; + operand.values[19] = OpcodeCodings603_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings604_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings604_19[] = { - {CODING_NAME("unpckhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpckhps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode604(x64Operand& operand) +asmError x64Parser::Opcode604(x64Operand &operand) { - operand.values[23] = OpcodeCodings604_23; - operand.values[19] = OpcodeCodings604_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings604_23; + operand.values[19] = OpcodeCodings604_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings605_23[] = { - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings605_19[] = { - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpcklpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode605(x64Operand& operand) +asmError x64Parser::Opcode605(x64Operand &operand) { - operand.values[23] = OpcodeCodings605_23; - operand.values[19] = OpcodeCodings605_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings605_23; + operand.values[19] = OpcodeCodings605_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings606_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings606_19[] = { - {CODING_NAME("unpcklps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unpcklps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode606(x64Operand& operand) +asmError x64Parser::Opcode606(x64Operand &operand) { - operand.values[23] = OpcodeCodings606_23; - operand.values[19] = OpcodeCodings606_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings606_23; + operand.values[19] = OpcodeCodings606_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings607_23[] = { - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings607_19[] = { - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("xorpd")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode607(x64Operand& operand) +asmError x64Parser::Opcode607(x64Operand &operand) { - operand.values[23] = OpcodeCodings607_23; - operand.values[19] = OpcodeCodings607_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings607_23; + operand.values[19] = OpcodeCodings607_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } Coding x64Parser::OpcodeCodings608_23[] = { - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings608_19[] = { - {CODING_NAME("xorps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("xorps")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode608(x64Operand& operand) +asmError x64Parser::Opcode608(x64Operand &operand) { - operand.values[23] = OpcodeCodings608_23; - operand.values[19] = OpcodeCodings608_19; - asmError rv; - { - rv = Opcode19(operand); - } - return rv; + operand.values[23] = OpcodeCodings608_23; + operand.values[19] = OpcodeCodings608_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; } -asmError x64Parser::Opcode609(x64Operand& operand) +asmError x64Parser::Opcode609(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode610(x64Operand& operand) +asmError x64Parser::Opcode610(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode611(x64Operand& operand) +asmError x64Parser::Opcode611(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode612(x64Operand& operand) +asmError x64Parser::Opcode612(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode613(x64Operand& operand) +asmError x64Parser::Opcode613(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode614(x64Operand& operand) +asmError x64Parser::Opcode614(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode615(x64Operand& operand) +asmError x64Parser::Opcode615(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode616(x64Operand& operand) +asmError x64Parser::Opcode616(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode617(x64Operand& operand) +asmError x64Parser::Opcode617(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode618(x64Operand& operand) +asmError x64Parser::Opcode618(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode619(x64Operand& operand) +asmError x64Parser::Opcode619(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } -asmError x64Parser::Opcode620(x64Operand& operand) +asmError x64Parser::Opcode620(x64Operand &operand) { - asmError rv = AERR_NONE; - return rv; + asmError rv = AERR_NONE; + return rv; } x64Parser::DispatchType x64Parser::DispatchTable[621] = { - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - NULL, - &x64Parser::Opcode32, - &x64Parser::Opcode33, - &x64Parser::Opcode34, - &x64Parser::Opcode35, - &x64Parser::Opcode36, - &x64Parser::Opcode37, - &x64Parser::Opcode38, - &x64Parser::Opcode39, - &x64Parser::Opcode40, - &x64Parser::Opcode41, - &x64Parser::Opcode42, - &x64Parser::Opcode43, - &x64Parser::Opcode44, - &x64Parser::Opcode45, - &x64Parser::Opcode46, - &x64Parser::Opcode47, - &x64Parser::Opcode48, - &x64Parser::Opcode49, - &x64Parser::Opcode50, - &x64Parser::Opcode51, - &x64Parser::Opcode52, - &x64Parser::Opcode53, - &x64Parser::Opcode54, - &x64Parser::Opcode55, - &x64Parser::Opcode56, - &x64Parser::Opcode57, - &x64Parser::Opcode58, - &x64Parser::Opcode59, - &x64Parser::Opcode60, - &x64Parser::Opcode61, - &x64Parser::Opcode62, - &x64Parser::Opcode63, - &x64Parser::Opcode64, - &x64Parser::Opcode65, - &x64Parser::Opcode66, - &x64Parser::Opcode67, - &x64Parser::Opcode68, - &x64Parser::Opcode69, - &x64Parser::Opcode70, - &x64Parser::Opcode71, - &x64Parser::Opcode72, - &x64Parser::Opcode73, - &x64Parser::Opcode74, - &x64Parser::Opcode75, - &x64Parser::Opcode76, - &x64Parser::Opcode77, - &x64Parser::Opcode78, - &x64Parser::Opcode79, - &x64Parser::Opcode80, - &x64Parser::Opcode81, - &x64Parser::Opcode82, - &x64Parser::Opcode83, - &x64Parser::Opcode84, - &x64Parser::Opcode85, - &x64Parser::Opcode86, - &x64Parser::Opcode87, - &x64Parser::Opcode88, - &x64Parser::Opcode89, - &x64Parser::Opcode90, - &x64Parser::Opcode91, - &x64Parser::Opcode92, - &x64Parser::Opcode93, - &x64Parser::Opcode94, - &x64Parser::Opcode95, - &x64Parser::Opcode96, - &x64Parser::Opcode97, - &x64Parser::Opcode98, - &x64Parser::Opcode99, - &x64Parser::Opcode100, - &x64Parser::Opcode101, - &x64Parser::Opcode102, - &x64Parser::Opcode103, - &x64Parser::Opcode104, - &x64Parser::Opcode105, - &x64Parser::Opcode106, - &x64Parser::Opcode107, - &x64Parser::Opcode108, - &x64Parser::Opcode109, - &x64Parser::Opcode110, - &x64Parser::Opcode111, - &x64Parser::Opcode112, - &x64Parser::Opcode113, - &x64Parser::Opcode114, - &x64Parser::Opcode115, - &x64Parser::Opcode116, - &x64Parser::Opcode117, - &x64Parser::Opcode118, - &x64Parser::Opcode119, - &x64Parser::Opcode120, - &x64Parser::Opcode121, - &x64Parser::Opcode122, - &x64Parser::Opcode123, - &x64Parser::Opcode124, - &x64Parser::Opcode125, - &x64Parser::Opcode126, - &x64Parser::Opcode127, - &x64Parser::Opcode128, - &x64Parser::Opcode129, - &x64Parser::Opcode130, - &x64Parser::Opcode131, - &x64Parser::Opcode132, - &x64Parser::Opcode133, - &x64Parser::Opcode134, - &x64Parser::Opcode135, - &x64Parser::Opcode136, - &x64Parser::Opcode137, - &x64Parser::Opcode138, - &x64Parser::Opcode139, - &x64Parser::Opcode140, - &x64Parser::Opcode141, - &x64Parser::Opcode142, - &x64Parser::Opcode143, - &x64Parser::Opcode144, - &x64Parser::Opcode145, - &x64Parser::Opcode146, - &x64Parser::Opcode147, - &x64Parser::Opcode148, - &x64Parser::Opcode149, - &x64Parser::Opcode150, - &x64Parser::Opcode151, - &x64Parser::Opcode152, - &x64Parser::Opcode153, - &x64Parser::Opcode154, - &x64Parser::Opcode155, - &x64Parser::Opcode156, - &x64Parser::Opcode157, - &x64Parser::Opcode158, - &x64Parser::Opcode159, - &x64Parser::Opcode160, - &x64Parser::Opcode161, - &x64Parser::Opcode162, - &x64Parser::Opcode163, - &x64Parser::Opcode164, - &x64Parser::Opcode165, - &x64Parser::Opcode166, - &x64Parser::Opcode167, - &x64Parser::Opcode168, - &x64Parser::Opcode169, - &x64Parser::Opcode170, - &x64Parser::Opcode171, - &x64Parser::Opcode172, - &x64Parser::Opcode173, - &x64Parser::Opcode174, - &x64Parser::Opcode175, - &x64Parser::Opcode176, - &x64Parser::Opcode177, - &x64Parser::Opcode178, - &x64Parser::Opcode179, - &x64Parser::Opcode180, - &x64Parser::Opcode181, - &x64Parser::Opcode182, - &x64Parser::Opcode183, - &x64Parser::Opcode184, - &x64Parser::Opcode185, - &x64Parser::Opcode186, - &x64Parser::Opcode187, - &x64Parser::Opcode188, - &x64Parser::Opcode189, - &x64Parser::Opcode190, - &x64Parser::Opcode191, - &x64Parser::Opcode192, - &x64Parser::Opcode193, - &x64Parser::Opcode194, - &x64Parser::Opcode195, - &x64Parser::Opcode196, - &x64Parser::Opcode197, - &x64Parser::Opcode198, - &x64Parser::Opcode199, - &x64Parser::Opcode200, - &x64Parser::Opcode201, - &x64Parser::Opcode202, - &x64Parser::Opcode203, - &x64Parser::Opcode204, - &x64Parser::Opcode205, - &x64Parser::Opcode206, - &x64Parser::Opcode207, - &x64Parser::Opcode208, - &x64Parser::Opcode209, - &x64Parser::Opcode210, - &x64Parser::Opcode211, - &x64Parser::Opcode212, - &x64Parser::Opcode213, - &x64Parser::Opcode214, - &x64Parser::Opcode215, - &x64Parser::Opcode216, - &x64Parser::Opcode217, - &x64Parser::Opcode218, - &x64Parser::Opcode219, - &x64Parser::Opcode220, - &x64Parser::Opcode221, - &x64Parser::Opcode222, - &x64Parser::Opcode223, - &x64Parser::Opcode224, - &x64Parser::Opcode225, - &x64Parser::Opcode226, - &x64Parser::Opcode227, - &x64Parser::Opcode228, - &x64Parser::Opcode229, - &x64Parser::Opcode230, - &x64Parser::Opcode231, - &x64Parser::Opcode232, - &x64Parser::Opcode233, - &x64Parser::Opcode234, - &x64Parser::Opcode235, - &x64Parser::Opcode236, - &x64Parser::Opcode237, - &x64Parser::Opcode238, - &x64Parser::Opcode239, - &x64Parser::Opcode240, - &x64Parser::Opcode241, - &x64Parser::Opcode242, - &x64Parser::Opcode243, - &x64Parser::Opcode244, - &x64Parser::Opcode245, - &x64Parser::Opcode246, - &x64Parser::Opcode247, - &x64Parser::Opcode248, - &x64Parser::Opcode249, - &x64Parser::Opcode250, - &x64Parser::Opcode251, - &x64Parser::Opcode252, - &x64Parser::Opcode253, - &x64Parser::Opcode254, - &x64Parser::Opcode255, - &x64Parser::Opcode256, - &x64Parser::Opcode257, - &x64Parser::Opcode258, - &x64Parser::Opcode259, - &x64Parser::Opcode260, - &x64Parser::Opcode261, - &x64Parser::Opcode262, - &x64Parser::Opcode263, - &x64Parser::Opcode264, - &x64Parser::Opcode265, - &x64Parser::Opcode266, - &x64Parser::Opcode267, - &x64Parser::Opcode268, - &x64Parser::Opcode269, - &x64Parser::Opcode270, - &x64Parser::Opcode271, - &x64Parser::Opcode272, - &x64Parser::Opcode273, - &x64Parser::Opcode274, - &x64Parser::Opcode275, - &x64Parser::Opcode276, - &x64Parser::Opcode277, - &x64Parser::Opcode278, - &x64Parser::Opcode279, - &x64Parser::Opcode280, - &x64Parser::Opcode281, - &x64Parser::Opcode282, - &x64Parser::Opcode283, - &x64Parser::Opcode284, - &x64Parser::Opcode285, - &x64Parser::Opcode286, - &x64Parser::Opcode287, - &x64Parser::Opcode288, - &x64Parser::Opcode289, - &x64Parser::Opcode290, - &x64Parser::Opcode291, - &x64Parser::Opcode292, - &x64Parser::Opcode293, - &x64Parser::Opcode294, - &x64Parser::Opcode295, - &x64Parser::Opcode296, - &x64Parser::Opcode297, - &x64Parser::Opcode298, - &x64Parser::Opcode299, - &x64Parser::Opcode300, - &x64Parser::Opcode301, - &x64Parser::Opcode302, - &x64Parser::Opcode303, - &x64Parser::Opcode304, - &x64Parser::Opcode305, - &x64Parser::Opcode306, - &x64Parser::Opcode307, - &x64Parser::Opcode308, - &x64Parser::Opcode309, - &x64Parser::Opcode310, - &x64Parser::Opcode311, - &x64Parser::Opcode312, - &x64Parser::Opcode313, - &x64Parser::Opcode314, - &x64Parser::Opcode315, - &x64Parser::Opcode316, - &x64Parser::Opcode317, - &x64Parser::Opcode318, - &x64Parser::Opcode319, - &x64Parser::Opcode320, - &x64Parser::Opcode321, - &x64Parser::Opcode322, - &x64Parser::Opcode323, - &x64Parser::Opcode324, - &x64Parser::Opcode325, - &x64Parser::Opcode326, - &x64Parser::Opcode327, - &x64Parser::Opcode328, - &x64Parser::Opcode329, - &x64Parser::Opcode330, - &x64Parser::Opcode331, - &x64Parser::Opcode332, - &x64Parser::Opcode333, - &x64Parser::Opcode334, - &x64Parser::Opcode335, - &x64Parser::Opcode336, - &x64Parser::Opcode337, - &x64Parser::Opcode338, - &x64Parser::Opcode339, - &x64Parser::Opcode340, - &x64Parser::Opcode341, - &x64Parser::Opcode342, - &x64Parser::Opcode343, - &x64Parser::Opcode344, - &x64Parser::Opcode345, - &x64Parser::Opcode346, - &x64Parser::Opcode347, - &x64Parser::Opcode348, - &x64Parser::Opcode349, - &x64Parser::Opcode350, - &x64Parser::Opcode351, - &x64Parser::Opcode352, - &x64Parser::Opcode353, - &x64Parser::Opcode354, - &x64Parser::Opcode355, - &x64Parser::Opcode356, - &x64Parser::Opcode357, - &x64Parser::Opcode358, - &x64Parser::Opcode359, - &x64Parser::Opcode360, - &x64Parser::Opcode361, - &x64Parser::Opcode362, - &x64Parser::Opcode363, - &x64Parser::Opcode364, - &x64Parser::Opcode365, - &x64Parser::Opcode366, - &x64Parser::Opcode367, - &x64Parser::Opcode368, - &x64Parser::Opcode369, - &x64Parser::Opcode370, - &x64Parser::Opcode371, - &x64Parser::Opcode372, - &x64Parser::Opcode373, - &x64Parser::Opcode374, - &x64Parser::Opcode375, - &x64Parser::Opcode376, - &x64Parser::Opcode377, - &x64Parser::Opcode378, - &x64Parser::Opcode379, - &x64Parser::Opcode380, - &x64Parser::Opcode381, - &x64Parser::Opcode382, - &x64Parser::Opcode383, - &x64Parser::Opcode384, - &x64Parser::Opcode385, - &x64Parser::Opcode386, - &x64Parser::Opcode387, - &x64Parser::Opcode388, - &x64Parser::Opcode389, - &x64Parser::Opcode390, - &x64Parser::Opcode391, - &x64Parser::Opcode392, - &x64Parser::Opcode393, - &x64Parser::Opcode394, - &x64Parser::Opcode395, - &x64Parser::Opcode396, - &x64Parser::Opcode397, - &x64Parser::Opcode398, - &x64Parser::Opcode399, - &x64Parser::Opcode400, - &x64Parser::Opcode401, - &x64Parser::Opcode402, - &x64Parser::Opcode403, - &x64Parser::Opcode404, - &x64Parser::Opcode405, - &x64Parser::Opcode406, - &x64Parser::Opcode407, - &x64Parser::Opcode408, - &x64Parser::Opcode409, - &x64Parser::Opcode410, - &x64Parser::Opcode411, - &x64Parser::Opcode412, - &x64Parser::Opcode413, - &x64Parser::Opcode414, - &x64Parser::Opcode415, - &x64Parser::Opcode416, - &x64Parser::Opcode417, - &x64Parser::Opcode418, - &x64Parser::Opcode419, - &x64Parser::Opcode420, - &x64Parser::Opcode421, - &x64Parser::Opcode422, - &x64Parser::Opcode423, - &x64Parser::Opcode424, - &x64Parser::Opcode425, - &x64Parser::Opcode426, - &x64Parser::Opcode427, - &x64Parser::Opcode428, - &x64Parser::Opcode429, - &x64Parser::Opcode430, - &x64Parser::Opcode431, - &x64Parser::Opcode432, - &x64Parser::Opcode433, - &x64Parser::Opcode434, - &x64Parser::Opcode435, - &x64Parser::Opcode436, - &x64Parser::Opcode437, - &x64Parser::Opcode438, - &x64Parser::Opcode439, - &x64Parser::Opcode440, - &x64Parser::Opcode441, - &x64Parser::Opcode442, - &x64Parser::Opcode443, - &x64Parser::Opcode444, - &x64Parser::Opcode445, - &x64Parser::Opcode446, - &x64Parser::Opcode447, - &x64Parser::Opcode448, - &x64Parser::Opcode449, - &x64Parser::Opcode450, - &x64Parser::Opcode451, - &x64Parser::Opcode452, - &x64Parser::Opcode453, - &x64Parser::Opcode454, - &x64Parser::Opcode455, - &x64Parser::Opcode456, - &x64Parser::Opcode457, - &x64Parser::Opcode458, - &x64Parser::Opcode459, - &x64Parser::Opcode460, - &x64Parser::Opcode461, - &x64Parser::Opcode462, - &x64Parser::Opcode463, - &x64Parser::Opcode464, - &x64Parser::Opcode465, - &x64Parser::Opcode466, - &x64Parser::Opcode467, - &x64Parser::Opcode468, - &x64Parser::Opcode469, - &x64Parser::Opcode470, - &x64Parser::Opcode471, - &x64Parser::Opcode472, - &x64Parser::Opcode473, - &x64Parser::Opcode474, - &x64Parser::Opcode475, - &x64Parser::Opcode476, - &x64Parser::Opcode477, - &x64Parser::Opcode478, - &x64Parser::Opcode479, - &x64Parser::Opcode480, - &x64Parser::Opcode481, - &x64Parser::Opcode482, - &x64Parser::Opcode483, - &x64Parser::Opcode484, - &x64Parser::Opcode485, - &x64Parser::Opcode486, - &x64Parser::Opcode487, - &x64Parser::Opcode488, - &x64Parser::Opcode489, - &x64Parser::Opcode490, - &x64Parser::Opcode491, - &x64Parser::Opcode492, - &x64Parser::Opcode493, - &x64Parser::Opcode494, - &x64Parser::Opcode495, - &x64Parser::Opcode496, - &x64Parser::Opcode497, - &x64Parser::Opcode498, - &x64Parser::Opcode499, - &x64Parser::Opcode500, - &x64Parser::Opcode501, - &x64Parser::Opcode502, - &x64Parser::Opcode503, - &x64Parser::Opcode504, - &x64Parser::Opcode505, - &x64Parser::Opcode506, - &x64Parser::Opcode507, - &x64Parser::Opcode508, - &x64Parser::Opcode509, - &x64Parser::Opcode510, - &x64Parser::Opcode511, - &x64Parser::Opcode512, - &x64Parser::Opcode513, - &x64Parser::Opcode514, - &x64Parser::Opcode515, - &x64Parser::Opcode516, - &x64Parser::Opcode517, - &x64Parser::Opcode518, - &x64Parser::Opcode519, - &x64Parser::Opcode520, - &x64Parser::Opcode521, - &x64Parser::Opcode522, - &x64Parser::Opcode523, - &x64Parser::Opcode524, - &x64Parser::Opcode525, - &x64Parser::Opcode526, - &x64Parser::Opcode527, - &x64Parser::Opcode528, - &x64Parser::Opcode529, - &x64Parser::Opcode530, - &x64Parser::Opcode531, - &x64Parser::Opcode532, - &x64Parser::Opcode533, - &x64Parser::Opcode534, - &x64Parser::Opcode535, - &x64Parser::Opcode536, - &x64Parser::Opcode537, - &x64Parser::Opcode538, - &x64Parser::Opcode539, - &x64Parser::Opcode540, - &x64Parser::Opcode541, - &x64Parser::Opcode542, - &x64Parser::Opcode543, - &x64Parser::Opcode544, - &x64Parser::Opcode545, - &x64Parser::Opcode546, - &x64Parser::Opcode547, - &x64Parser::Opcode548, - &x64Parser::Opcode549, - &x64Parser::Opcode550, - &x64Parser::Opcode551, - &x64Parser::Opcode552, - &x64Parser::Opcode553, - &x64Parser::Opcode554, - &x64Parser::Opcode555, - &x64Parser::Opcode556, - &x64Parser::Opcode557, - &x64Parser::Opcode558, - &x64Parser::Opcode559, - &x64Parser::Opcode560, - &x64Parser::Opcode561, - &x64Parser::Opcode562, - &x64Parser::Opcode563, - &x64Parser::Opcode564, - &x64Parser::Opcode565, - &x64Parser::Opcode566, - &x64Parser::Opcode567, - &x64Parser::Opcode568, - &x64Parser::Opcode569, - &x64Parser::Opcode570, - &x64Parser::Opcode571, - &x64Parser::Opcode572, - &x64Parser::Opcode573, - &x64Parser::Opcode574, - &x64Parser::Opcode575, - &x64Parser::Opcode576, - &x64Parser::Opcode577, - &x64Parser::Opcode578, - &x64Parser::Opcode579, - &x64Parser::Opcode580, - &x64Parser::Opcode581, - &x64Parser::Opcode582, - &x64Parser::Opcode583, - &x64Parser::Opcode584, - &x64Parser::Opcode585, - &x64Parser::Opcode586, - &x64Parser::Opcode587, - &x64Parser::Opcode588, - &x64Parser::Opcode589, - &x64Parser::Opcode590, - &x64Parser::Opcode591, - &x64Parser::Opcode592, - &x64Parser::Opcode593, - &x64Parser::Opcode594, - &x64Parser::Opcode595, - &x64Parser::Opcode596, - &x64Parser::Opcode597, - &x64Parser::Opcode598, - &x64Parser::Opcode599, - &x64Parser::Opcode600, - &x64Parser::Opcode601, - &x64Parser::Opcode602, - &x64Parser::Opcode603, - &x64Parser::Opcode604, - &x64Parser::Opcode605, - &x64Parser::Opcode606, - &x64Parser::Opcode607, - &x64Parser::Opcode608, - &x64Parser::Opcode609, - &x64Parser::Opcode610, - &x64Parser::Opcode611, - &x64Parser::Opcode612, - &x64Parser::Opcode613, - &x64Parser::Opcode614, - &x64Parser::Opcode615, - &x64Parser::Opcode616, - &x64Parser::Opcode617, - &x64Parser::Opcode618, - &x64Parser::Opcode619, - &x64Parser::Opcode620, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + &x64Parser::Opcode32, + &x64Parser::Opcode33, + &x64Parser::Opcode34, + &x64Parser::Opcode35, + &x64Parser::Opcode36, + &x64Parser::Opcode37, + &x64Parser::Opcode38, + &x64Parser::Opcode39, + &x64Parser::Opcode40, + &x64Parser::Opcode41, + &x64Parser::Opcode42, + &x64Parser::Opcode43, + &x64Parser::Opcode44, + &x64Parser::Opcode45, + &x64Parser::Opcode46, + &x64Parser::Opcode47, + &x64Parser::Opcode48, + &x64Parser::Opcode49, + &x64Parser::Opcode50, + &x64Parser::Opcode51, + &x64Parser::Opcode52, + &x64Parser::Opcode53, + &x64Parser::Opcode54, + &x64Parser::Opcode55, + &x64Parser::Opcode56, + &x64Parser::Opcode57, + &x64Parser::Opcode58, + &x64Parser::Opcode59, + &x64Parser::Opcode60, + &x64Parser::Opcode61, + &x64Parser::Opcode62, + &x64Parser::Opcode63, + &x64Parser::Opcode64, + &x64Parser::Opcode65, + &x64Parser::Opcode66, + &x64Parser::Opcode67, + &x64Parser::Opcode68, + &x64Parser::Opcode69, + &x64Parser::Opcode70, + &x64Parser::Opcode71, + &x64Parser::Opcode72, + &x64Parser::Opcode73, + &x64Parser::Opcode74, + &x64Parser::Opcode75, + &x64Parser::Opcode76, + &x64Parser::Opcode77, + &x64Parser::Opcode78, + &x64Parser::Opcode79, + &x64Parser::Opcode80, + &x64Parser::Opcode81, + &x64Parser::Opcode82, + &x64Parser::Opcode83, + &x64Parser::Opcode84, + &x64Parser::Opcode85, + &x64Parser::Opcode86, + &x64Parser::Opcode87, + &x64Parser::Opcode88, + &x64Parser::Opcode89, + &x64Parser::Opcode90, + &x64Parser::Opcode91, + &x64Parser::Opcode92, + &x64Parser::Opcode93, + &x64Parser::Opcode94, + &x64Parser::Opcode95, + &x64Parser::Opcode96, + &x64Parser::Opcode97, + &x64Parser::Opcode98, + &x64Parser::Opcode99, + &x64Parser::Opcode100, + &x64Parser::Opcode101, + &x64Parser::Opcode102, + &x64Parser::Opcode103, + &x64Parser::Opcode104, + &x64Parser::Opcode105, + &x64Parser::Opcode106, + &x64Parser::Opcode107, + &x64Parser::Opcode108, + &x64Parser::Opcode109, + &x64Parser::Opcode110, + &x64Parser::Opcode111, + &x64Parser::Opcode112, + &x64Parser::Opcode113, + &x64Parser::Opcode114, + &x64Parser::Opcode115, + &x64Parser::Opcode116, + &x64Parser::Opcode117, + &x64Parser::Opcode118, + &x64Parser::Opcode119, + &x64Parser::Opcode120, + &x64Parser::Opcode121, + &x64Parser::Opcode122, + &x64Parser::Opcode123, + &x64Parser::Opcode124, + &x64Parser::Opcode125, + &x64Parser::Opcode126, + &x64Parser::Opcode127, + &x64Parser::Opcode128, + &x64Parser::Opcode129, + &x64Parser::Opcode130, + &x64Parser::Opcode131, + &x64Parser::Opcode132, + &x64Parser::Opcode133, + &x64Parser::Opcode134, + &x64Parser::Opcode135, + &x64Parser::Opcode136, + &x64Parser::Opcode137, + &x64Parser::Opcode138, + &x64Parser::Opcode139, + &x64Parser::Opcode140, + &x64Parser::Opcode141, + &x64Parser::Opcode142, + &x64Parser::Opcode143, + &x64Parser::Opcode144, + &x64Parser::Opcode145, + &x64Parser::Opcode146, + &x64Parser::Opcode147, + &x64Parser::Opcode148, + &x64Parser::Opcode149, + &x64Parser::Opcode150, + &x64Parser::Opcode151, + &x64Parser::Opcode152, + &x64Parser::Opcode153, + &x64Parser::Opcode154, + &x64Parser::Opcode155, + &x64Parser::Opcode156, + &x64Parser::Opcode157, + &x64Parser::Opcode158, + &x64Parser::Opcode159, + &x64Parser::Opcode160, + &x64Parser::Opcode161, + &x64Parser::Opcode162, + &x64Parser::Opcode163, + &x64Parser::Opcode164, + &x64Parser::Opcode165, + &x64Parser::Opcode166, + &x64Parser::Opcode167, + &x64Parser::Opcode168, + &x64Parser::Opcode169, + &x64Parser::Opcode170, + &x64Parser::Opcode171, + &x64Parser::Opcode172, + &x64Parser::Opcode173, + &x64Parser::Opcode174, + &x64Parser::Opcode175, + &x64Parser::Opcode176, + &x64Parser::Opcode177, + &x64Parser::Opcode178, + &x64Parser::Opcode179, + &x64Parser::Opcode180, + &x64Parser::Opcode181, + &x64Parser::Opcode182, + &x64Parser::Opcode183, + &x64Parser::Opcode184, + &x64Parser::Opcode185, + &x64Parser::Opcode186, + &x64Parser::Opcode187, + &x64Parser::Opcode188, + &x64Parser::Opcode189, + &x64Parser::Opcode190, + &x64Parser::Opcode191, + &x64Parser::Opcode192, + &x64Parser::Opcode193, + &x64Parser::Opcode194, + &x64Parser::Opcode195, + &x64Parser::Opcode196, + &x64Parser::Opcode197, + &x64Parser::Opcode198, + &x64Parser::Opcode199, + &x64Parser::Opcode200, + &x64Parser::Opcode201, + &x64Parser::Opcode202, + &x64Parser::Opcode203, + &x64Parser::Opcode204, + &x64Parser::Opcode205, + &x64Parser::Opcode206, + &x64Parser::Opcode207, + &x64Parser::Opcode208, + &x64Parser::Opcode209, + &x64Parser::Opcode210, + &x64Parser::Opcode211, + &x64Parser::Opcode212, + &x64Parser::Opcode213, + &x64Parser::Opcode214, + &x64Parser::Opcode215, + &x64Parser::Opcode216, + &x64Parser::Opcode217, + &x64Parser::Opcode218, + &x64Parser::Opcode219, + &x64Parser::Opcode220, + &x64Parser::Opcode221, + &x64Parser::Opcode222, + &x64Parser::Opcode223, + &x64Parser::Opcode224, + &x64Parser::Opcode225, + &x64Parser::Opcode226, + &x64Parser::Opcode227, + &x64Parser::Opcode228, + &x64Parser::Opcode229, + &x64Parser::Opcode230, + &x64Parser::Opcode231, + &x64Parser::Opcode232, + &x64Parser::Opcode233, + &x64Parser::Opcode234, + &x64Parser::Opcode235, + &x64Parser::Opcode236, + &x64Parser::Opcode237, + &x64Parser::Opcode238, + &x64Parser::Opcode239, + &x64Parser::Opcode240, + &x64Parser::Opcode241, + &x64Parser::Opcode242, + &x64Parser::Opcode243, + &x64Parser::Opcode244, + &x64Parser::Opcode245, + &x64Parser::Opcode246, + &x64Parser::Opcode247, + &x64Parser::Opcode248, + &x64Parser::Opcode249, + &x64Parser::Opcode250, + &x64Parser::Opcode251, + &x64Parser::Opcode252, + &x64Parser::Opcode253, + &x64Parser::Opcode254, + &x64Parser::Opcode255, + &x64Parser::Opcode256, + &x64Parser::Opcode257, + &x64Parser::Opcode258, + &x64Parser::Opcode259, + &x64Parser::Opcode260, + &x64Parser::Opcode261, + &x64Parser::Opcode262, + &x64Parser::Opcode263, + &x64Parser::Opcode264, + &x64Parser::Opcode265, + &x64Parser::Opcode266, + &x64Parser::Opcode267, + &x64Parser::Opcode268, + &x64Parser::Opcode269, + &x64Parser::Opcode270, + &x64Parser::Opcode271, + &x64Parser::Opcode272, + &x64Parser::Opcode273, + &x64Parser::Opcode274, + &x64Parser::Opcode275, + &x64Parser::Opcode276, + &x64Parser::Opcode277, + &x64Parser::Opcode278, + &x64Parser::Opcode279, + &x64Parser::Opcode280, + &x64Parser::Opcode281, + &x64Parser::Opcode282, + &x64Parser::Opcode283, + &x64Parser::Opcode284, + &x64Parser::Opcode285, + &x64Parser::Opcode286, + &x64Parser::Opcode287, + &x64Parser::Opcode288, + &x64Parser::Opcode289, + &x64Parser::Opcode290, + &x64Parser::Opcode291, + &x64Parser::Opcode292, + &x64Parser::Opcode293, + &x64Parser::Opcode294, + &x64Parser::Opcode295, + &x64Parser::Opcode296, + &x64Parser::Opcode297, + &x64Parser::Opcode298, + &x64Parser::Opcode299, + &x64Parser::Opcode300, + &x64Parser::Opcode301, + &x64Parser::Opcode302, + &x64Parser::Opcode303, + &x64Parser::Opcode304, + &x64Parser::Opcode305, + &x64Parser::Opcode306, + &x64Parser::Opcode307, + &x64Parser::Opcode308, + &x64Parser::Opcode309, + &x64Parser::Opcode310, + &x64Parser::Opcode311, + &x64Parser::Opcode312, + &x64Parser::Opcode313, + &x64Parser::Opcode314, + &x64Parser::Opcode315, + &x64Parser::Opcode316, + &x64Parser::Opcode317, + &x64Parser::Opcode318, + &x64Parser::Opcode319, + &x64Parser::Opcode320, + &x64Parser::Opcode321, + &x64Parser::Opcode322, + &x64Parser::Opcode323, + &x64Parser::Opcode324, + &x64Parser::Opcode325, + &x64Parser::Opcode326, + &x64Parser::Opcode327, + &x64Parser::Opcode328, + &x64Parser::Opcode329, + &x64Parser::Opcode330, + &x64Parser::Opcode331, + &x64Parser::Opcode332, + &x64Parser::Opcode333, + &x64Parser::Opcode334, + &x64Parser::Opcode335, + &x64Parser::Opcode336, + &x64Parser::Opcode337, + &x64Parser::Opcode338, + &x64Parser::Opcode339, + &x64Parser::Opcode340, + &x64Parser::Opcode341, + &x64Parser::Opcode342, + &x64Parser::Opcode343, + &x64Parser::Opcode344, + &x64Parser::Opcode345, + &x64Parser::Opcode346, + &x64Parser::Opcode347, + &x64Parser::Opcode348, + &x64Parser::Opcode349, + &x64Parser::Opcode350, + &x64Parser::Opcode351, + &x64Parser::Opcode352, + &x64Parser::Opcode353, + &x64Parser::Opcode354, + &x64Parser::Opcode355, + &x64Parser::Opcode356, + &x64Parser::Opcode357, + &x64Parser::Opcode358, + &x64Parser::Opcode359, + &x64Parser::Opcode360, + &x64Parser::Opcode361, + &x64Parser::Opcode362, + &x64Parser::Opcode363, + &x64Parser::Opcode364, + &x64Parser::Opcode365, + &x64Parser::Opcode366, + &x64Parser::Opcode367, + &x64Parser::Opcode368, + &x64Parser::Opcode369, + &x64Parser::Opcode370, + &x64Parser::Opcode371, + &x64Parser::Opcode372, + &x64Parser::Opcode373, + &x64Parser::Opcode374, + &x64Parser::Opcode375, + &x64Parser::Opcode376, + &x64Parser::Opcode377, + &x64Parser::Opcode378, + &x64Parser::Opcode379, + &x64Parser::Opcode380, + &x64Parser::Opcode381, + &x64Parser::Opcode382, + &x64Parser::Opcode383, + &x64Parser::Opcode384, + &x64Parser::Opcode385, + &x64Parser::Opcode386, + &x64Parser::Opcode387, + &x64Parser::Opcode388, + &x64Parser::Opcode389, + &x64Parser::Opcode390, + &x64Parser::Opcode391, + &x64Parser::Opcode392, + &x64Parser::Opcode393, + &x64Parser::Opcode394, + &x64Parser::Opcode395, + &x64Parser::Opcode396, + &x64Parser::Opcode397, + &x64Parser::Opcode398, + &x64Parser::Opcode399, + &x64Parser::Opcode400, + &x64Parser::Opcode401, + &x64Parser::Opcode402, + &x64Parser::Opcode403, + &x64Parser::Opcode404, + &x64Parser::Opcode405, + &x64Parser::Opcode406, + &x64Parser::Opcode407, + &x64Parser::Opcode408, + &x64Parser::Opcode409, + &x64Parser::Opcode410, + &x64Parser::Opcode411, + &x64Parser::Opcode412, + &x64Parser::Opcode413, + &x64Parser::Opcode414, + &x64Parser::Opcode415, + &x64Parser::Opcode416, + &x64Parser::Opcode417, + &x64Parser::Opcode418, + &x64Parser::Opcode419, + &x64Parser::Opcode420, + &x64Parser::Opcode421, + &x64Parser::Opcode422, + &x64Parser::Opcode423, + &x64Parser::Opcode424, + &x64Parser::Opcode425, + &x64Parser::Opcode426, + &x64Parser::Opcode427, + &x64Parser::Opcode428, + &x64Parser::Opcode429, + &x64Parser::Opcode430, + &x64Parser::Opcode431, + &x64Parser::Opcode432, + &x64Parser::Opcode433, + &x64Parser::Opcode434, + &x64Parser::Opcode435, + &x64Parser::Opcode436, + &x64Parser::Opcode437, + &x64Parser::Opcode438, + &x64Parser::Opcode439, + &x64Parser::Opcode440, + &x64Parser::Opcode441, + &x64Parser::Opcode442, + &x64Parser::Opcode443, + &x64Parser::Opcode444, + &x64Parser::Opcode445, + &x64Parser::Opcode446, + &x64Parser::Opcode447, + &x64Parser::Opcode448, + &x64Parser::Opcode449, + &x64Parser::Opcode450, + &x64Parser::Opcode451, + &x64Parser::Opcode452, + &x64Parser::Opcode453, + &x64Parser::Opcode454, + &x64Parser::Opcode455, + &x64Parser::Opcode456, + &x64Parser::Opcode457, + &x64Parser::Opcode458, + &x64Parser::Opcode459, + &x64Parser::Opcode460, + &x64Parser::Opcode461, + &x64Parser::Opcode462, + &x64Parser::Opcode463, + &x64Parser::Opcode464, + &x64Parser::Opcode465, + &x64Parser::Opcode466, + &x64Parser::Opcode467, + &x64Parser::Opcode468, + &x64Parser::Opcode469, + &x64Parser::Opcode470, + &x64Parser::Opcode471, + &x64Parser::Opcode472, + &x64Parser::Opcode473, + &x64Parser::Opcode474, + &x64Parser::Opcode475, + &x64Parser::Opcode476, + &x64Parser::Opcode477, + &x64Parser::Opcode478, + &x64Parser::Opcode479, + &x64Parser::Opcode480, + &x64Parser::Opcode481, + &x64Parser::Opcode482, + &x64Parser::Opcode483, + &x64Parser::Opcode484, + &x64Parser::Opcode485, + &x64Parser::Opcode486, + &x64Parser::Opcode487, + &x64Parser::Opcode488, + &x64Parser::Opcode489, + &x64Parser::Opcode490, + &x64Parser::Opcode491, + &x64Parser::Opcode492, + &x64Parser::Opcode493, + &x64Parser::Opcode494, + &x64Parser::Opcode495, + &x64Parser::Opcode496, + &x64Parser::Opcode497, + &x64Parser::Opcode498, + &x64Parser::Opcode499, + &x64Parser::Opcode500, + &x64Parser::Opcode501, + &x64Parser::Opcode502, + &x64Parser::Opcode503, + &x64Parser::Opcode504, + &x64Parser::Opcode505, + &x64Parser::Opcode506, + &x64Parser::Opcode507, + &x64Parser::Opcode508, + &x64Parser::Opcode509, + &x64Parser::Opcode510, + &x64Parser::Opcode511, + &x64Parser::Opcode512, + &x64Parser::Opcode513, + &x64Parser::Opcode514, + &x64Parser::Opcode515, + &x64Parser::Opcode516, + &x64Parser::Opcode517, + &x64Parser::Opcode518, + &x64Parser::Opcode519, + &x64Parser::Opcode520, + &x64Parser::Opcode521, + &x64Parser::Opcode522, + &x64Parser::Opcode523, + &x64Parser::Opcode524, + &x64Parser::Opcode525, + &x64Parser::Opcode526, + &x64Parser::Opcode527, + &x64Parser::Opcode528, + &x64Parser::Opcode529, + &x64Parser::Opcode530, + &x64Parser::Opcode531, + &x64Parser::Opcode532, + &x64Parser::Opcode533, + &x64Parser::Opcode534, + &x64Parser::Opcode535, + &x64Parser::Opcode536, + &x64Parser::Opcode537, + &x64Parser::Opcode538, + &x64Parser::Opcode539, + &x64Parser::Opcode540, + &x64Parser::Opcode541, + &x64Parser::Opcode542, + &x64Parser::Opcode543, + &x64Parser::Opcode544, + &x64Parser::Opcode545, + &x64Parser::Opcode546, + &x64Parser::Opcode547, + &x64Parser::Opcode548, + &x64Parser::Opcode549, + &x64Parser::Opcode550, + &x64Parser::Opcode551, + &x64Parser::Opcode552, + &x64Parser::Opcode553, + &x64Parser::Opcode554, + &x64Parser::Opcode555, + &x64Parser::Opcode556, + &x64Parser::Opcode557, + &x64Parser::Opcode558, + &x64Parser::Opcode559, + &x64Parser::Opcode560, + &x64Parser::Opcode561, + &x64Parser::Opcode562, + &x64Parser::Opcode563, + &x64Parser::Opcode564, + &x64Parser::Opcode565, + &x64Parser::Opcode566, + &x64Parser::Opcode567, + &x64Parser::Opcode568, + &x64Parser::Opcode569, + &x64Parser::Opcode570, + &x64Parser::Opcode571, + &x64Parser::Opcode572, + &x64Parser::Opcode573, + &x64Parser::Opcode574, + &x64Parser::Opcode575, + &x64Parser::Opcode576, + &x64Parser::Opcode577, + &x64Parser::Opcode578, + &x64Parser::Opcode579, + &x64Parser::Opcode580, + &x64Parser::Opcode581, + &x64Parser::Opcode582, + &x64Parser::Opcode583, + &x64Parser::Opcode584, + &x64Parser::Opcode585, + &x64Parser::Opcode586, + &x64Parser::Opcode587, + &x64Parser::Opcode588, + &x64Parser::Opcode589, + &x64Parser::Opcode590, + &x64Parser::Opcode591, + &x64Parser::Opcode592, + &x64Parser::Opcode593, + &x64Parser::Opcode594, + &x64Parser::Opcode595, + &x64Parser::Opcode596, + &x64Parser::Opcode597, + &x64Parser::Opcode598, + &x64Parser::Opcode599, + &x64Parser::Opcode600, + &x64Parser::Opcode601, + &x64Parser::Opcode602, + &x64Parser::Opcode603, + &x64Parser::Opcode604, + &x64Parser::Opcode605, + &x64Parser::Opcode606, + &x64Parser::Opcode607, + &x64Parser::Opcode608, + &x64Parser::Opcode609, + &x64Parser::Opcode610, + &x64Parser::Opcode611, + &x64Parser::Opcode612, + &x64Parser::Opcode613, + &x64Parser::Opcode614, + &x64Parser::Opcode615, + &x64Parser::Opcode616, + &x64Parser::Opcode617, + &x64Parser::Opcode618, + &x64Parser::Opcode619, + &x64Parser::Opcode620, }; -x64Token* x64Parser::addressTable[] = { - &x64Parser::tokenBranches3[0], &x64Parser::tokenBranches8[0], &x64Parser::tokenBranches199[0], - &x64Parser::tokenBranches345[0], &x64Parser::tokenBranches198[0], &x64Parser::tokenBranches35[0], - &x64Parser::tokenBranches136[0], &x64Parser::tokenBranches282[0], &x64Parser::tokenBranches428[0], - &x64Parser::tokenBranches34[0], &x64Parser::tokenBranches33[0], &x64Parser::tokenBranches226[0], - &x64Parser::tokenBranches372[0], &x64Parser::tokenBranches225[0], &x64Parser::tokenBranches56[0], - &x64Parser::tokenBranches169[0], &x64Parser::tokenBranches315[0], &x64Parser::tokenBranches461[0], - &x64Parser::tokenBranches55[0], &x64Parser::tokenBranches54[0], &x64Parser::tokenBranches256[0], - &x64Parser::tokenBranches402[0], &x64Parser::tokenBranches255[0], &x64Parser::tokenBranches78[0], - &x64Parser::tokenBranches605[0], &x64Parser::tokenBranches701[0], &x64Parser::tokenBranches825[0], - &x64Parser::tokenBranches2120[0], &x64Parser::tokenBranches2679[0], &x64Parser::tokenBranches2950[0], - &x64Parser::tokenBranches2119[0], &x64Parser::tokenBranches2118[0], &x64Parser::tokenBranches2117[0], - &x64Parser::tokenBranches2129[0], &x64Parser::tokenBranches2688[0], &x64Parser::tokenBranches2959[0], - &x64Parser::tokenBranches2128[0], &x64Parser::tokenBranches2116[0], &x64Parser::tokenBranches604[0], - &x64Parser::tokenBranches505[0], &x64Parser::tokenBranches612[0], &x64Parser::tokenBranches708[0], - &x64Parser::tokenBranches832[0], &x64Parser::tokenBranches2100[0], &x64Parser::tokenBranches2659[0], - &x64Parser::tokenBranches2930[0], &x64Parser::tokenBranches2099[0], &x64Parser::tokenBranches2098[0], - &x64Parser::tokenBranches2097[0], &x64Parser::tokenBranches2109[0], &x64Parser::tokenBranches2668[0], - &x64Parser::tokenBranches2939[0], &x64Parser::tokenBranches2108[0], &x64Parser::tokenBranches2096[0], - &x64Parser::tokenBranches2218[0], &x64Parser::tokenBranches2630[0], &x64Parser::tokenBranches3008[0], - &x64Parser::tokenBranches2217[0], &x64Parser::tokenBranches2216[0], &x64Parser::tokenBranches611[0], - &x64Parser::tokenBranches974[0], &x64Parser::tokenBranches983[0], &x64Parser::tokenBranches992[0], - &x64Parser::tokenBranches973[0], &x64Parser::tokenBranches965[0], &x64Parser::tokenBranches1102[0], - &x64Parser::tokenBranches1111[0], &x64Parser::tokenBranches1120[0], &x64Parser::tokenBranches1101[0], - &x64Parser::tokenBranches1093[0], &x64Parser::tokenBranches1479[0], &x64Parser::tokenBranches1488[0], - &x64Parser::tokenBranches1478[0], &x64Parser::tokenBranches1470[0], &x64Parser::tokenBranches964[0], - &x64Parser::tokenBranches510[0], &x64Parser::tokenBranches652[0], &x64Parser::tokenBranches776[0], - &x64Parser::tokenBranches900[0], &x64Parser::tokenBranches651[0], &x64Parser::tokenBranches537[0], - &x64Parser::tokenBranches643[0], &x64Parser::tokenBranches767[0], &x64Parser::tokenBranches891[0], - &x64Parser::tokenBranches2299[0], &x64Parser::tokenBranches2831[0], &x64Parser::tokenBranches3129[0], - &x64Parser::tokenBranches2298[0], &x64Parser::tokenBranches2297[0], &x64Parser::tokenBranches2296[0], - &x64Parser::tokenBranches2308[0], &x64Parser::tokenBranches2840[0], &x64Parser::tokenBranches3138[0], - &x64Parser::tokenBranches2307[0], &x64Parser::tokenBranches2295[0], &x64Parser::tokenBranches536[0], - &x64Parser::tokenBranches1624[0], &x64Parser::tokenBranches1633[0], &x64Parser::tokenBranches1642[0], - &x64Parser::tokenBranches1623[0], &x64Parser::tokenBranches1615[0], &x64Parser::tokenBranches1752[0], - &x64Parser::tokenBranches1761[0], &x64Parser::tokenBranches1770[0], &x64Parser::tokenBranches1751[0], - &x64Parser::tokenBranches1743[0], &x64Parser::tokenBranches1898[0], &x64Parser::tokenBranches1907[0], - &x64Parser::tokenBranches1927[0], &x64Parser::tokenBranches1938[0], &x64Parser::tokenBranches1926[0], - &x64Parser::tokenBranches1916[0], &x64Parser::tokenBranches1897[0], &x64Parser::tokenBranches1889[0], - &x64Parser::tokenBranches1614[0], &x64Parser::tokenBranches525[0], &x64Parser::tokenBranches564[0], - &x64Parser::tokenBranches1230[0], &x64Parser::tokenBranches1239[0], &x64Parser::tokenBranches1248[0], - &x64Parser::tokenBranches1229[0], &x64Parser::tokenBranches1221[0], &x64Parser::tokenBranches1358[0], - &x64Parser::tokenBranches1367[0], &x64Parser::tokenBranches1376[0], &x64Parser::tokenBranches1357[0], - &x64Parser::tokenBranches1349[0], &x64Parser::tokenBranches1220[0], &x64Parser::tokenBranches1219[0], - &x64Parser::tokenBranches3747[0], &x64Parser::tokenBranches3756[0], &x64Parser::tokenBranches3765[0], - &x64Parser::tokenBranches3746[0], &x64Parser::tokenBranches3738[0], &x64Parser::tokenBranches3875[0], - &x64Parser::tokenBranches3884[0], &x64Parser::tokenBranches3893[0], &x64Parser::tokenBranches3874[0], - &x64Parser::tokenBranches3866[0], &x64Parser::tokenBranches3737[0], &x64Parser::tokenBranches3736[0], - &x64Parser::tokenBranches4003[0], &x64Parser::tokenBranches4012[0], &x64Parser::tokenBranches4021[0], - &x64Parser::tokenBranches4002[0], &x64Parser::tokenBranches3994[0], &x64Parser::tokenBranches4131[0], - &x64Parser::tokenBranches4140[0], &x64Parser::tokenBranches4149[0], &x64Parser::tokenBranches4130[0], - &x64Parser::tokenBranches4122[0], &x64Parser::tokenBranches3993[0], &x64Parser::tokenBranches3992[0], - &x64Parser::tokenBranches7[0], &x64Parser::tokenBranches6[0], &x64Parser::tokenBranches13[0], - &x64Parser::tokenBranches208[0], &x64Parser::tokenBranches354[0], &x64Parser::tokenBranches207[0], - &x64Parser::tokenBranches42[0], &x64Parser::tokenBranches143[0], &x64Parser::tokenBranches289[0], - &x64Parser::tokenBranches435[0], &x64Parser::tokenBranches41[0], &x64Parser::tokenBranches40[0], - &x64Parser::tokenBranches217[0], &x64Parser::tokenBranches363[0], &x64Parser::tokenBranches216[0], - &x64Parser::tokenBranches49[0], &x64Parser::tokenBranches162[0], &x64Parser::tokenBranches308[0], - &x64Parser::tokenBranches454[0], &x64Parser::tokenBranches48[0], &x64Parser::tokenBranches47[0], - &x64Parser::tokenBranches263[0], &x64Parser::tokenBranches409[0], &x64Parser::tokenBranches262[0], - &x64Parser::tokenBranches83[0], &x64Parser::tokenBranches591[0], &x64Parser::tokenBranches715[0], - &x64Parser::tokenBranches839[0], &x64Parser::tokenBranches2160[0], &x64Parser::tokenBranches2719[0], - &x64Parser::tokenBranches2990[0], &x64Parser::tokenBranches2159[0], &x64Parser::tokenBranches2158[0], - &x64Parser::tokenBranches2157[0], &x64Parser::tokenBranches2169[0], &x64Parser::tokenBranches2728[0], - &x64Parser::tokenBranches2999[0], &x64Parser::tokenBranches2168[0], &x64Parser::tokenBranches2156[0], - &x64Parser::tokenBranches590[0], &x64Parser::tokenBranches515[0], &x64Parser::tokenBranches598[0], - &x64Parser::tokenBranches722[0], &x64Parser::tokenBranches846[0], &x64Parser::tokenBranches2140[0], - &x64Parser::tokenBranches2699[0], &x64Parser::tokenBranches2970[0], &x64Parser::tokenBranches2139[0], - &x64Parser::tokenBranches2138[0], &x64Parser::tokenBranches2137[0], &x64Parser::tokenBranches2149[0], - &x64Parser::tokenBranches2708[0], &x64Parser::tokenBranches2979[0], &x64Parser::tokenBranches2148[0], - &x64Parser::tokenBranches2136[0], &x64Parser::tokenBranches2227[0], &x64Parser::tokenBranches2639[0], - &x64Parser::tokenBranches3017[0], &x64Parser::tokenBranches2226[0], &x64Parser::tokenBranches2225[0], - &x64Parser::tokenBranches597[0], &x64Parser::tokenBranches1008[0], &x64Parser::tokenBranches1017[0], - &x64Parser::tokenBranches1026[0], &x64Parser::tokenBranches1007[0], &x64Parser::tokenBranches999[0], - &x64Parser::tokenBranches1136[0], &x64Parser::tokenBranches1145[0], &x64Parser::tokenBranches1154[0], - &x64Parser::tokenBranches1135[0], &x64Parser::tokenBranches1127[0], &x64Parser::tokenBranches1504[0], - &x64Parser::tokenBranches1513[0], &x64Parser::tokenBranches1503[0], &x64Parser::tokenBranches1495[0], - &x64Parser::tokenBranches998[0], &x64Parser::tokenBranches520[0], &x64Parser::tokenBranches668[0], - &x64Parser::tokenBranches792[0], &x64Parser::tokenBranches916[0], &x64Parser::tokenBranches667[0], - &x64Parser::tokenBranches544[0], &x64Parser::tokenBranches659[0], &x64Parser::tokenBranches783[0], - &x64Parser::tokenBranches907[0], &x64Parser::tokenBranches2319[0], &x64Parser::tokenBranches2851[0], - &x64Parser::tokenBranches3149[0], &x64Parser::tokenBranches2318[0], &x64Parser::tokenBranches2317[0], - &x64Parser::tokenBranches2316[0], &x64Parser::tokenBranches2328[0], &x64Parser::tokenBranches2860[0], - &x64Parser::tokenBranches3158[0], &x64Parser::tokenBranches2327[0], &x64Parser::tokenBranches2315[0], - &x64Parser::tokenBranches543[0], &x64Parser::tokenBranches1658[0], &x64Parser::tokenBranches1667[0], - &x64Parser::tokenBranches1676[0], &x64Parser::tokenBranches1657[0], &x64Parser::tokenBranches1649[0], - &x64Parser::tokenBranches1786[0], &x64Parser::tokenBranches1795[0], &x64Parser::tokenBranches1804[0], - &x64Parser::tokenBranches1785[0], &x64Parser::tokenBranches1777[0], &x64Parser::tokenBranches1954[0], - &x64Parser::tokenBranches1963[0], &x64Parser::tokenBranches1983[0], &x64Parser::tokenBranches1994[0], - &x64Parser::tokenBranches1982[0], &x64Parser::tokenBranches1972[0], &x64Parser::tokenBranches1953[0], - &x64Parser::tokenBranches1945[0], &x64Parser::tokenBranches1648[0], &x64Parser::tokenBranches530[0], - &x64Parser::tokenBranches569[0], &x64Parser::tokenBranches1264[0], &x64Parser::tokenBranches1273[0], - &x64Parser::tokenBranches1282[0], &x64Parser::tokenBranches1263[0], &x64Parser::tokenBranches1255[0], - &x64Parser::tokenBranches1392[0], &x64Parser::tokenBranches1401[0], &x64Parser::tokenBranches1410[0], - &x64Parser::tokenBranches1391[0], &x64Parser::tokenBranches1383[0], &x64Parser::tokenBranches1254[0], - &x64Parser::tokenBranches1253[0], &x64Parser::tokenBranches3781[0], &x64Parser::tokenBranches3790[0], - &x64Parser::tokenBranches3799[0], &x64Parser::tokenBranches3780[0], &x64Parser::tokenBranches3772[0], - &x64Parser::tokenBranches3909[0], &x64Parser::tokenBranches3918[0], &x64Parser::tokenBranches3927[0], - &x64Parser::tokenBranches3908[0], &x64Parser::tokenBranches3900[0], &x64Parser::tokenBranches3771[0], - &x64Parser::tokenBranches3770[0], &x64Parser::tokenBranches4037[0], &x64Parser::tokenBranches4046[0], - &x64Parser::tokenBranches4055[0], &x64Parser::tokenBranches4036[0], &x64Parser::tokenBranches4028[0], - &x64Parser::tokenBranches4165[0], &x64Parser::tokenBranches4174[0], &x64Parser::tokenBranches4183[0], - &x64Parser::tokenBranches4164[0], &x64Parser::tokenBranches4156[0], &x64Parser::tokenBranches4027[0], - &x64Parser::tokenBranches4026[0], &x64Parser::tokenBranches12[0], &x64Parser::tokenBranches11[0], - &x64Parser::tokenBranches18[0], &x64Parser::tokenBranches235[0], &x64Parser::tokenBranches381[0], - &x64Parser::tokenBranches234[0], &x64Parser::tokenBranches63[0], &x64Parser::tokenBranches150[0], - &x64Parser::tokenBranches296[0], &x64Parser::tokenBranches442[0], &x64Parser::tokenBranches62[0], - &x64Parser::tokenBranches61[0], &x64Parser::tokenBranches244[0], &x64Parser::tokenBranches390[0], - &x64Parser::tokenBranches243[0], &x64Parser::tokenBranches70[0], &x64Parser::tokenBranches176[0], - &x64Parser::tokenBranches322[0], &x64Parser::tokenBranches468[0], &x64Parser::tokenBranches69[0], - &x64Parser::tokenBranches68[0], &x64Parser::tokenBranches270[0], &x64Parser::tokenBranches416[0], - &x64Parser::tokenBranches269[0], &x64Parser::tokenBranches88[0], &x64Parser::tokenBranches729[0], - &x64Parser::tokenBranches853[0], &x64Parser::tokenBranches2200[0], &x64Parser::tokenBranches2759[0], - &x64Parser::tokenBranches3057[0], &x64Parser::tokenBranches2199[0], &x64Parser::tokenBranches2198[0], - &x64Parser::tokenBranches2197[0], &x64Parser::tokenBranches2209[0], &x64Parser::tokenBranches2768[0], - &x64Parser::tokenBranches3066[0], &x64Parser::tokenBranches2208[0], &x64Parser::tokenBranches2196[0], - &x64Parser::tokenBranches728[0], &x64Parser::tokenBranches490[0], &x64Parser::tokenBranches736[0], - &x64Parser::tokenBranches860[0], &x64Parser::tokenBranches2180[0], &x64Parser::tokenBranches2739[0], - &x64Parser::tokenBranches3037[0], &x64Parser::tokenBranches2179[0], &x64Parser::tokenBranches2178[0], - &x64Parser::tokenBranches2177[0], &x64Parser::tokenBranches2189[0], &x64Parser::tokenBranches2748[0], - &x64Parser::tokenBranches3046[0], &x64Parser::tokenBranches2188[0], &x64Parser::tokenBranches2176[0], - &x64Parser::tokenBranches2236[0], &x64Parser::tokenBranches2648[0], &x64Parser::tokenBranches3026[0], - &x64Parser::tokenBranches2235[0], &x64Parser::tokenBranches2234[0], &x64Parser::tokenBranches735[0], - &x64Parser::tokenBranches1042[0], &x64Parser::tokenBranches1051[0], &x64Parser::tokenBranches1060[0], - &x64Parser::tokenBranches1041[0], &x64Parser::tokenBranches1033[0], &x64Parser::tokenBranches1170[0], - &x64Parser::tokenBranches1179[0], &x64Parser::tokenBranches1188[0], &x64Parser::tokenBranches1169[0], - &x64Parser::tokenBranches1161[0], &x64Parser::tokenBranches1529[0], &x64Parser::tokenBranches1538[0], - &x64Parser::tokenBranches1528[0], &x64Parser::tokenBranches1520[0], &x64Parser::tokenBranches1032[0], - &x64Parser::tokenBranches495[0], &x64Parser::tokenBranches636[0], &x64Parser::tokenBranches760[0], - &x64Parser::tokenBranches884[0], &x64Parser::tokenBranches2279[0], &x64Parser::tokenBranches2811[0], - &x64Parser::tokenBranches3109[0], &x64Parser::tokenBranches2278[0], &x64Parser::tokenBranches2277[0], - &x64Parser::tokenBranches2276[0], &x64Parser::tokenBranches2288[0], &x64Parser::tokenBranches2820[0], - &x64Parser::tokenBranches3118[0], &x64Parser::tokenBranches2287[0], &x64Parser::tokenBranches2275[0], - &x64Parser::tokenBranches635[0], &x64Parser::tokenBranches1298[0], &x64Parser::tokenBranches1307[0], - &x64Parser::tokenBranches1316[0], &x64Parser::tokenBranches1297[0], &x64Parser::tokenBranches1289[0], - &x64Parser::tokenBranches1426[0], &x64Parser::tokenBranches1435[0], &x64Parser::tokenBranches1444[0], - &x64Parser::tokenBranches1425[0], &x64Parser::tokenBranches1417[0], &x64Parser::tokenBranches1573[0], - &x64Parser::tokenBranches1582[0], &x64Parser::tokenBranches1572[0], &x64Parser::tokenBranches1564[0], - &x64Parser::tokenBranches1288[0], &x64Parser::tokenBranches500[0], &x64Parser::tokenBranches684[0], - &x64Parser::tokenBranches808[0], &x64Parser::tokenBranches925[0], &x64Parser::tokenBranches683[0], - &x64Parser::tokenBranches556[0], &x64Parser::tokenBranches675[0], &x64Parser::tokenBranches799[0], - &x64Parser::tokenBranches932[0], &x64Parser::tokenBranches2339[0], &x64Parser::tokenBranches2871[0], - &x64Parser::tokenBranches3169[0], &x64Parser::tokenBranches2338[0], &x64Parser::tokenBranches2337[0], - &x64Parser::tokenBranches2336[0], &x64Parser::tokenBranches2348[0], &x64Parser::tokenBranches2880[0], - &x64Parser::tokenBranches3178[0], &x64Parser::tokenBranches2347[0], &x64Parser::tokenBranches2335[0], - &x64Parser::tokenBranches555[0], &x64Parser::tokenBranches1692[0], &x64Parser::tokenBranches1701[0], - &x64Parser::tokenBranches1710[0], &x64Parser::tokenBranches1691[0], &x64Parser::tokenBranches1683[0], - &x64Parser::tokenBranches1820[0], &x64Parser::tokenBranches1829[0], &x64Parser::tokenBranches1838[0], - &x64Parser::tokenBranches1819[0], &x64Parser::tokenBranches1811[0], &x64Parser::tokenBranches2010[0], - &x64Parser::tokenBranches2019[0], &x64Parser::tokenBranches2039[0], &x64Parser::tokenBranches2050[0], - &x64Parser::tokenBranches2038[0], &x64Parser::tokenBranches2028[0], &x64Parser::tokenBranches2009[0], - &x64Parser::tokenBranches2001[0], &x64Parser::tokenBranches1682[0], &x64Parser::tokenBranches549[0], - &x64Parser::tokenBranches574[0], &x64Parser::tokenBranches3276[0], &x64Parser::tokenBranches3367[0], - &x64Parser::tokenBranches3459[0], &x64Parser::tokenBranches4568[0], &x64Parser::tokenBranches4944[0], - &x64Parser::tokenBranches5156[0], &x64Parser::tokenBranches4567[0], &x64Parser::tokenBranches4566[0], - &x64Parser::tokenBranches4565[0], &x64Parser::tokenBranches4577[0], &x64Parser::tokenBranches4953[0], - &x64Parser::tokenBranches5165[0], &x64Parser::tokenBranches4576[0], &x64Parser::tokenBranches4564[0], - &x64Parser::tokenBranches3275[0], &x64Parser::tokenBranches3195[0], &x64Parser::tokenBranches3336[0], - &x64Parser::tokenBranches3428[0], &x64Parser::tokenBranches3520[0], &x64Parser::tokenBranches3335[0], - &x64Parser::tokenBranches3235[0], &x64Parser::tokenBranches3374[0], &x64Parser::tokenBranches3466[0], - &x64Parser::tokenBranches4588[0], &x64Parser::tokenBranches4964[0], &x64Parser::tokenBranches5176[0], - &x64Parser::tokenBranches4587[0], &x64Parser::tokenBranches4586[0], &x64Parser::tokenBranches4585[0], - &x64Parser::tokenBranches4597[0], &x64Parser::tokenBranches4973[0], &x64Parser::tokenBranches5185[0], - &x64Parser::tokenBranches4596[0], &x64Parser::tokenBranches4584[0], &x64Parser::tokenBranches3234[0], - &x64Parser::tokenBranches3282[0], &x64Parser::tokenBranches3571[0], &x64Parser::tokenBranches3580[0], - &x64Parser::tokenBranches3589[0], &x64Parser::tokenBranches3570[0], &x64Parser::tokenBranches3562[0], - &x64Parser::tokenBranches3631[0], &x64Parser::tokenBranches3640[0], &x64Parser::tokenBranches3649[0], - &x64Parser::tokenBranches3630[0], &x64Parser::tokenBranches3622[0], &x64Parser::tokenBranches3677[0], - &x64Parser::tokenBranches3676[0], &x64Parser::tokenBranches3668[0], &x64Parser::tokenBranches3705[0], - &x64Parser::tokenBranches3704[0], &x64Parser::tokenBranches3696[0], &x64Parser::tokenBranches3561[0], - &x64Parser::tokenBranches3200[0], &x64Parser::tokenBranches3289[0], &x64Parser::tokenBranches3381[0], - &x64Parser::tokenBranches3473[0], &x64Parser::tokenBranches4480[0], &x64Parser::tokenBranches4856[0], - &x64Parser::tokenBranches5068[0], &x64Parser::tokenBranches4479[0], &x64Parser::tokenBranches4478[0], - &x64Parser::tokenBranches4548[0], &x64Parser::tokenBranches4924[0], &x64Parser::tokenBranches5136[0], - &x64Parser::tokenBranches4547[0], &x64Parser::tokenBranches4546[0], &x64Parser::tokenBranches4545[0], - &x64Parser::tokenBranches4557[0], &x64Parser::tokenBranches4933[0], &x64Parser::tokenBranches5145[0], - &x64Parser::tokenBranches4556[0], &x64Parser::tokenBranches4544[0], &x64Parser::tokenBranches3288[0], - &x64Parser::tokenBranches3815[0], &x64Parser::tokenBranches3824[0], &x64Parser::tokenBranches3833[0], - &x64Parser::tokenBranches3814[0], &x64Parser::tokenBranches3806[0], &x64Parser::tokenBranches3943[0], - &x64Parser::tokenBranches3952[0], &x64Parser::tokenBranches3961[0], &x64Parser::tokenBranches3942[0], - &x64Parser::tokenBranches3934[0], &x64Parser::tokenBranches4245[0], &x64Parser::tokenBranches4244[0], - &x64Parser::tokenBranches4236[0], &x64Parser::tokenBranches3805[0], &x64Parser::tokenBranches3205[0], - &x64Parser::tokenBranches3320[0], &x64Parser::tokenBranches3412[0], &x64Parser::tokenBranches3504[0], - &x64Parser::tokenBranches4489[0], &x64Parser::tokenBranches4865[0], &x64Parser::tokenBranches5077[0], - &x64Parser::tokenBranches4488[0], &x64Parser::tokenBranches4487[0], &x64Parser::tokenBranches4640[0], - &x64Parser::tokenBranches5016[0], &x64Parser::tokenBranches5228[0], &x64Parser::tokenBranches4639[0], - &x64Parser::tokenBranches4638[0], &x64Parser::tokenBranches4637[0], &x64Parser::tokenBranches4649[0], - &x64Parser::tokenBranches5025[0], &x64Parser::tokenBranches5237[0], &x64Parser::tokenBranches4648[0], - &x64Parser::tokenBranches4636[0], &x64Parser::tokenBranches3319[0], &x64Parser::tokenBranches4071[0], - &x64Parser::tokenBranches4080[0], &x64Parser::tokenBranches4089[0], &x64Parser::tokenBranches4070[0], - &x64Parser::tokenBranches4062[0], &x64Parser::tokenBranches4199[0], &x64Parser::tokenBranches4208[0], - &x64Parser::tokenBranches4217[0], &x64Parser::tokenBranches4198[0], &x64Parser::tokenBranches4190[0], - &x64Parser::tokenBranches4273[0], &x64Parser::tokenBranches4272[0], &x64Parser::tokenBranches4264[0], - &x64Parser::tokenBranches4061[0], &x64Parser::tokenBranches3210[0], &x64Parser::tokenBranches3345[0], - &x64Parser::tokenBranches3437[0], &x64Parser::tokenBranches3529[0], &x64Parser::tokenBranches3344[0], - &x64Parser::tokenBranches3242[0], &x64Parser::tokenBranches3327[0], &x64Parser::tokenBranches3419[0], - &x64Parser::tokenBranches3511[0], &x64Parser::tokenBranches4660[0], &x64Parser::tokenBranches5036[0], - &x64Parser::tokenBranches5248[0], &x64Parser::tokenBranches4659[0], &x64Parser::tokenBranches4658[0], - &x64Parser::tokenBranches4657[0], &x64Parser::tokenBranches4669[0], &x64Parser::tokenBranches5045[0], - &x64Parser::tokenBranches5257[0], &x64Parser::tokenBranches4668[0], &x64Parser::tokenBranches4656[0], - &x64Parser::tokenBranches3241[0], &x64Parser::tokenBranches4315[0], &x64Parser::tokenBranches4324[0], - &x64Parser::tokenBranches4333[0], &x64Parser::tokenBranches4314[0], &x64Parser::tokenBranches4306[0], - &x64Parser::tokenBranches4375[0], &x64Parser::tokenBranches4384[0], &x64Parser::tokenBranches4393[0], - &x64Parser::tokenBranches4374[0], &x64Parser::tokenBranches4366[0], &x64Parser::tokenBranches4437[0], - &x64Parser::tokenBranches4457[0], &x64Parser::tokenBranches4456[0], &x64Parser::tokenBranches4446[0], - &x64Parser::tokenBranches4436[0], &x64Parser::tokenBranches4428[0], &x64Parser::tokenBranches4305[0], - &x64Parser::tokenBranches3228[0], &x64Parser::tokenBranches3255[0], &x64Parser::tokenBranches17[0], - &x64Parser::tokenBranches16[0], &x64Parser::tokenBranches183[0], &x64Parser::tokenBranches329[0], - &x64Parser::tokenBranches182[0], &x64Parser::tokenBranches23[0], &x64Parser::tokenBranches129[0], - &x64Parser::tokenBranches275[0], &x64Parser::tokenBranches421[0], &x64Parser::tokenBranches22[0], - &x64Parser::tokenBranches21[0], &x64Parser::tokenBranches190[0], &x64Parser::tokenBranches336[0], - &x64Parser::tokenBranches189[0], &x64Parser::tokenBranches28[0], &x64Parser::tokenBranches155[0], - &x64Parser::tokenBranches301[0], &x64Parser::tokenBranches447[0], &x64Parser::tokenBranches27[0], - &x64Parser::tokenBranches26[0], &x64Parser::tokenBranches249[0], &x64Parser::tokenBranches395[0], - &x64Parser::tokenBranches248[0], &x64Parser::tokenBranches73[0], &x64Parser::tokenBranches579[0], - &x64Parser::tokenBranches689[0], &x64Parser::tokenBranches813[0], &x64Parser::tokenBranches2082[0], - &x64Parser::tokenBranches2614[0], &x64Parser::tokenBranches2912[0], &x64Parser::tokenBranches2081[0], - &x64Parser::tokenBranches2080[0], &x64Parser::tokenBranches2079[0], &x64Parser::tokenBranches2089[0], - &x64Parser::tokenBranches2621[0], &x64Parser::tokenBranches2919[0], &x64Parser::tokenBranches2088[0], - &x64Parser::tokenBranches2078[0], &x64Parser::tokenBranches578[0], &x64Parser::tokenBranches471[0], - &x64Parser::tokenBranches584[0], &x64Parser::tokenBranches694[0], &x64Parser::tokenBranches818[0], - &x64Parser::tokenBranches2057[0], &x64Parser::tokenBranches2589[0], &x64Parser::tokenBranches2887[0], - &x64Parser::tokenBranches2056[0], &x64Parser::tokenBranches2055[0], &x64Parser::tokenBranches2066[0], - &x64Parser::tokenBranches2598[0], &x64Parser::tokenBranches2896[0], &x64Parser::tokenBranches2065[0], - &x64Parser::tokenBranches2064[0], &x64Parser::tokenBranches2063[0], &x64Parser::tokenBranches2073[0], - &x64Parser::tokenBranches2605[0], &x64Parser::tokenBranches2903[0], &x64Parser::tokenBranches2072[0], - &x64Parser::tokenBranches2062[0], &x64Parser::tokenBranches583[0], &x64Parser::tokenBranches944[0], - &x64Parser::tokenBranches951[0], &x64Parser::tokenBranches958[0], &x64Parser::tokenBranches943[0], - &x64Parser::tokenBranches937[0], &x64Parser::tokenBranches1072[0], &x64Parser::tokenBranches1079[0], - &x64Parser::tokenBranches1086[0], &x64Parser::tokenBranches1071[0], &x64Parser::tokenBranches1065[0], - &x64Parser::tokenBranches1456[0], &x64Parser::tokenBranches1463[0], &x64Parser::tokenBranches1455[0], - &x64Parser::tokenBranches1449[0], &x64Parser::tokenBranches936[0], &x64Parser::tokenBranches474[0], - &x64Parser::tokenBranches617[0], &x64Parser::tokenBranches741[0], &x64Parser::tokenBranches865[0], - &x64Parser::tokenBranches2245[0], &x64Parser::tokenBranches2777[0], &x64Parser::tokenBranches3075[0], - &x64Parser::tokenBranches2244[0], &x64Parser::tokenBranches2243[0], &x64Parser::tokenBranches2242[0], - &x64Parser::tokenBranches2252[0], &x64Parser::tokenBranches2784[0], &x64Parser::tokenBranches3082[0], - &x64Parser::tokenBranches2251[0], &x64Parser::tokenBranches2241[0], &x64Parser::tokenBranches616[0], - &x64Parser::tokenBranches1200[0], &x64Parser::tokenBranches1207[0], &x64Parser::tokenBranches1214[0], - &x64Parser::tokenBranches1199[0], &x64Parser::tokenBranches1193[0], &x64Parser::tokenBranches1328[0], - &x64Parser::tokenBranches1335[0], &x64Parser::tokenBranches1342[0], &x64Parser::tokenBranches1327[0], - &x64Parser::tokenBranches1321[0], &x64Parser::tokenBranches1550[0], &x64Parser::tokenBranches1557[0], - &x64Parser::tokenBranches1549[0], &x64Parser::tokenBranches1543[0], &x64Parser::tokenBranches1192[0], - &x64Parser::tokenBranches477[0], &x64Parser::tokenBranches629[0], &x64Parser::tokenBranches753[0], - &x64Parser::tokenBranches877[0], &x64Parser::tokenBranches628[0], &x64Parser::tokenBranches485[0], - &x64Parser::tokenBranches622[0], &x64Parser::tokenBranches746[0], &x64Parser::tokenBranches870[0], - &x64Parser::tokenBranches2261[0], &x64Parser::tokenBranches2793[0], &x64Parser::tokenBranches3091[0], - &x64Parser::tokenBranches2260[0], &x64Parser::tokenBranches2259[0], &x64Parser::tokenBranches2258[0], - &x64Parser::tokenBranches2268[0], &x64Parser::tokenBranches2800[0], &x64Parser::tokenBranches3098[0], - &x64Parser::tokenBranches2267[0], &x64Parser::tokenBranches2257[0], &x64Parser::tokenBranches484[0], - &x64Parser::tokenBranches1594[0], &x64Parser::tokenBranches1601[0], &x64Parser::tokenBranches1608[0], - &x64Parser::tokenBranches1593[0], &x64Parser::tokenBranches1587[0], &x64Parser::tokenBranches1722[0], - &x64Parser::tokenBranches1729[0], &x64Parser::tokenBranches1736[0], &x64Parser::tokenBranches1721[0], - &x64Parser::tokenBranches1715[0], &x64Parser::tokenBranches1850[0], &x64Parser::tokenBranches1857[0], - &x64Parser::tokenBranches1873[0], &x64Parser::tokenBranches1882[0], &x64Parser::tokenBranches1872[0], - &x64Parser::tokenBranches1864[0], &x64Parser::tokenBranches1849[0], &x64Parser::tokenBranches1843[0], - &x64Parser::tokenBranches1586[0], &x64Parser::tokenBranches480[0], &x64Parser::tokenBranches559[0], - &x64Parser::tokenBranches3260[0], &x64Parser::tokenBranches3350[0], &x64Parser::tokenBranches3442[0], - &x64Parser::tokenBranches4514[0], &x64Parser::tokenBranches4890[0], &x64Parser::tokenBranches5102[0], - &x64Parser::tokenBranches4513[0], &x64Parser::tokenBranches4512[0], &x64Parser::tokenBranches4511[0], - &x64Parser::tokenBranches4521[0], &x64Parser::tokenBranches4897[0], &x64Parser::tokenBranches5109[0], - &x64Parser::tokenBranches4520[0], &x64Parser::tokenBranches4510[0], &x64Parser::tokenBranches3259[0], - &x64Parser::tokenBranches3181[0], &x64Parser::tokenBranches3306[0], &x64Parser::tokenBranches3398[0], - &x64Parser::tokenBranches3490[0], &x64Parser::tokenBranches3305[0], &x64Parser::tokenBranches3218[0], - &x64Parser::tokenBranches3355[0], &x64Parser::tokenBranches3447[0], &x64Parser::tokenBranches4530[0], - &x64Parser::tokenBranches4906[0], &x64Parser::tokenBranches5118[0], &x64Parser::tokenBranches4529[0], - &x64Parser::tokenBranches4528[0], &x64Parser::tokenBranches4527[0], &x64Parser::tokenBranches4537[0], - &x64Parser::tokenBranches4913[0], &x64Parser::tokenBranches5125[0], &x64Parser::tokenBranches4536[0], - &x64Parser::tokenBranches4526[0], &x64Parser::tokenBranches3217[0], &x64Parser::tokenBranches3264[0], - &x64Parser::tokenBranches3541[0], &x64Parser::tokenBranches3548[0], &x64Parser::tokenBranches3555[0], - &x64Parser::tokenBranches3540[0], &x64Parser::tokenBranches3534[0], &x64Parser::tokenBranches3601[0], - &x64Parser::tokenBranches3608[0], &x64Parser::tokenBranches3615[0], &x64Parser::tokenBranches3600[0], - &x64Parser::tokenBranches3594[0], &x64Parser::tokenBranches3661[0], &x64Parser::tokenBranches3660[0], - &x64Parser::tokenBranches3654[0], &x64Parser::tokenBranches3689[0], &x64Parser::tokenBranches3688[0], - &x64Parser::tokenBranches3682[0], &x64Parser::tokenBranches3533[0], &x64Parser::tokenBranches3184[0], - &x64Parser::tokenBranches3269[0], &x64Parser::tokenBranches3360[0], &x64Parser::tokenBranches3452[0], - &x64Parser::tokenBranches4464[0], &x64Parser::tokenBranches4840[0], &x64Parser::tokenBranches5052[0], - &x64Parser::tokenBranches4463[0], &x64Parser::tokenBranches4462[0], &x64Parser::tokenBranches4498[0], - &x64Parser::tokenBranches4874[0], &x64Parser::tokenBranches5086[0], &x64Parser::tokenBranches4497[0], - &x64Parser::tokenBranches4496[0], &x64Parser::tokenBranches4495[0], &x64Parser::tokenBranches4505[0], - &x64Parser::tokenBranches4881[0], &x64Parser::tokenBranches5093[0], &x64Parser::tokenBranches4504[0], - &x64Parser::tokenBranches4494[0], &x64Parser::tokenBranches3268[0], &x64Parser::tokenBranches3717[0], - &x64Parser::tokenBranches3724[0], &x64Parser::tokenBranches3731[0], &x64Parser::tokenBranches3716[0], - &x64Parser::tokenBranches3710[0], &x64Parser::tokenBranches3845[0], &x64Parser::tokenBranches3852[0], - &x64Parser::tokenBranches3859[0], &x64Parser::tokenBranches3844[0], &x64Parser::tokenBranches3838[0], - &x64Parser::tokenBranches4229[0], &x64Parser::tokenBranches4228[0], &x64Parser::tokenBranches4222[0], - &x64Parser::tokenBranches3709[0], &x64Parser::tokenBranches3187[0], &x64Parser::tokenBranches3294[0], - &x64Parser::tokenBranches3386[0], &x64Parser::tokenBranches3478[0], &x64Parser::tokenBranches4471[0], - &x64Parser::tokenBranches4847[0], &x64Parser::tokenBranches5059[0], &x64Parser::tokenBranches4470[0], - &x64Parser::tokenBranches4469[0], &x64Parser::tokenBranches4606[0], &x64Parser::tokenBranches4982[0], - &x64Parser::tokenBranches5194[0], &x64Parser::tokenBranches4605[0], &x64Parser::tokenBranches4604[0], - &x64Parser::tokenBranches4603[0], &x64Parser::tokenBranches4613[0], &x64Parser::tokenBranches4989[0], - &x64Parser::tokenBranches5201[0], &x64Parser::tokenBranches4612[0], &x64Parser::tokenBranches4602[0], - &x64Parser::tokenBranches3293[0], &x64Parser::tokenBranches3973[0], &x64Parser::tokenBranches3980[0], - &x64Parser::tokenBranches3987[0], &x64Parser::tokenBranches3972[0], &x64Parser::tokenBranches3966[0], - &x64Parser::tokenBranches4101[0], &x64Parser::tokenBranches4108[0], &x64Parser::tokenBranches4115[0], - &x64Parser::tokenBranches4100[0], &x64Parser::tokenBranches4094[0], &x64Parser::tokenBranches4257[0], - &x64Parser::tokenBranches4256[0], &x64Parser::tokenBranches4250[0], &x64Parser::tokenBranches3965[0], - &x64Parser::tokenBranches3190[0], &x64Parser::tokenBranches3313[0], &x64Parser::tokenBranches3405[0], - &x64Parser::tokenBranches3497[0], &x64Parser::tokenBranches3312[0], &x64Parser::tokenBranches3223[0], - &x64Parser::tokenBranches3299[0], &x64Parser::tokenBranches3391[0], &x64Parser::tokenBranches3483[0], - &x64Parser::tokenBranches4622[0], &x64Parser::tokenBranches4998[0], &x64Parser::tokenBranches5210[0], - &x64Parser::tokenBranches4621[0], &x64Parser::tokenBranches4620[0], &x64Parser::tokenBranches4619[0], - &x64Parser::tokenBranches4629[0], &x64Parser::tokenBranches5005[0], &x64Parser::tokenBranches5217[0], - &x64Parser::tokenBranches4628[0], &x64Parser::tokenBranches4618[0], &x64Parser::tokenBranches3222[0], - &x64Parser::tokenBranches4285[0], &x64Parser::tokenBranches4292[0], &x64Parser::tokenBranches4299[0], - &x64Parser::tokenBranches4284[0], &x64Parser::tokenBranches4278[0], &x64Parser::tokenBranches4345[0], - &x64Parser::tokenBranches4352[0], &x64Parser::tokenBranches4359[0], &x64Parser::tokenBranches4344[0], - &x64Parser::tokenBranches4338[0], &x64Parser::tokenBranches4405[0], &x64Parser::tokenBranches4421[0], - &x64Parser::tokenBranches4420[0], &x64Parser::tokenBranches4412[0], &x64Parser::tokenBranches4404[0], - &x64Parser::tokenBranches4398[0], &x64Parser::tokenBranches4277[0], &x64Parser::tokenBranches3213[0], - &x64Parser::tokenBranches3247[0], &x64Parser::tokenBranches3246[0], &x64Parser::tokenBranches3245[0], - &x64Parser::tokenBranches3250[0], &x64Parser::tokenBranches2[0], &x64Parser::tokenBranches1[0], +x64Token *x64Parser::addressTable[] = { + &x64Parser::tokenBranches3[0], + &x64Parser::tokenBranches8[0], + &x64Parser::tokenBranches199[0], + &x64Parser::tokenBranches345[0], + &x64Parser::tokenBranches198[0], + &x64Parser::tokenBranches35[0], + &x64Parser::tokenBranches136[0], + &x64Parser::tokenBranches282[0], + &x64Parser::tokenBranches428[0], + &x64Parser::tokenBranches34[0], + &x64Parser::tokenBranches33[0], + &x64Parser::tokenBranches226[0], + &x64Parser::tokenBranches372[0], + &x64Parser::tokenBranches225[0], + &x64Parser::tokenBranches56[0], + &x64Parser::tokenBranches169[0], + &x64Parser::tokenBranches315[0], + &x64Parser::tokenBranches461[0], + &x64Parser::tokenBranches55[0], + &x64Parser::tokenBranches54[0], + &x64Parser::tokenBranches256[0], + &x64Parser::tokenBranches402[0], + &x64Parser::tokenBranches255[0], + &x64Parser::tokenBranches78[0], + &x64Parser::tokenBranches605[0], + &x64Parser::tokenBranches701[0], + &x64Parser::tokenBranches825[0], + &x64Parser::tokenBranches2120[0], + &x64Parser::tokenBranches2679[0], + &x64Parser::tokenBranches2950[0], + &x64Parser::tokenBranches2119[0], + &x64Parser::tokenBranches2118[0], + &x64Parser::tokenBranches2117[0], + &x64Parser::tokenBranches2129[0], + &x64Parser::tokenBranches2688[0], + &x64Parser::tokenBranches2959[0], + &x64Parser::tokenBranches2128[0], + &x64Parser::tokenBranches2116[0], + &x64Parser::tokenBranches604[0], + &x64Parser::tokenBranches505[0], + &x64Parser::tokenBranches612[0], + &x64Parser::tokenBranches708[0], + &x64Parser::tokenBranches832[0], + &x64Parser::tokenBranches2100[0], + &x64Parser::tokenBranches2659[0], + &x64Parser::tokenBranches2930[0], + &x64Parser::tokenBranches2099[0], + &x64Parser::tokenBranches2098[0], + &x64Parser::tokenBranches2097[0], + &x64Parser::tokenBranches2109[0], + &x64Parser::tokenBranches2668[0], + &x64Parser::tokenBranches2939[0], + &x64Parser::tokenBranches2108[0], + &x64Parser::tokenBranches2096[0], + &x64Parser::tokenBranches2218[0], + &x64Parser::tokenBranches2630[0], + &x64Parser::tokenBranches3008[0], + &x64Parser::tokenBranches2217[0], + &x64Parser::tokenBranches2216[0], + &x64Parser::tokenBranches611[0], + &x64Parser::tokenBranches974[0], + &x64Parser::tokenBranches983[0], + &x64Parser::tokenBranches992[0], + &x64Parser::tokenBranches973[0], + &x64Parser::tokenBranches965[0], + &x64Parser::tokenBranches1102[0], + &x64Parser::tokenBranches1111[0], + &x64Parser::tokenBranches1120[0], + &x64Parser::tokenBranches1101[0], + &x64Parser::tokenBranches1093[0], + &x64Parser::tokenBranches1479[0], + &x64Parser::tokenBranches1488[0], + &x64Parser::tokenBranches1478[0], + &x64Parser::tokenBranches1470[0], + &x64Parser::tokenBranches964[0], + &x64Parser::tokenBranches510[0], + &x64Parser::tokenBranches652[0], + &x64Parser::tokenBranches776[0], + &x64Parser::tokenBranches900[0], + &x64Parser::tokenBranches651[0], + &x64Parser::tokenBranches537[0], + &x64Parser::tokenBranches643[0], + &x64Parser::tokenBranches767[0], + &x64Parser::tokenBranches891[0], + &x64Parser::tokenBranches2299[0], + &x64Parser::tokenBranches2831[0], + &x64Parser::tokenBranches3129[0], + &x64Parser::tokenBranches2298[0], + &x64Parser::tokenBranches2297[0], + &x64Parser::tokenBranches2296[0], + &x64Parser::tokenBranches2308[0], + &x64Parser::tokenBranches2840[0], + &x64Parser::tokenBranches3138[0], + &x64Parser::tokenBranches2307[0], + &x64Parser::tokenBranches2295[0], + &x64Parser::tokenBranches536[0], + &x64Parser::tokenBranches1624[0], + &x64Parser::tokenBranches1633[0], + &x64Parser::tokenBranches1642[0], + &x64Parser::tokenBranches1623[0], + &x64Parser::tokenBranches1615[0], + &x64Parser::tokenBranches1752[0], + &x64Parser::tokenBranches1761[0], + &x64Parser::tokenBranches1770[0], + &x64Parser::tokenBranches1751[0], + &x64Parser::tokenBranches1743[0], + &x64Parser::tokenBranches1898[0], + &x64Parser::tokenBranches1907[0], + &x64Parser::tokenBranches1927[0], + &x64Parser::tokenBranches1938[0], + &x64Parser::tokenBranches1926[0], + &x64Parser::tokenBranches1916[0], + &x64Parser::tokenBranches1897[0], + &x64Parser::tokenBranches1889[0], + &x64Parser::tokenBranches1614[0], + &x64Parser::tokenBranches525[0], + &x64Parser::tokenBranches564[0], + &x64Parser::tokenBranches1230[0], + &x64Parser::tokenBranches1239[0], + &x64Parser::tokenBranches1248[0], + &x64Parser::tokenBranches1229[0], + &x64Parser::tokenBranches1221[0], + &x64Parser::tokenBranches1358[0], + &x64Parser::tokenBranches1367[0], + &x64Parser::tokenBranches1376[0], + &x64Parser::tokenBranches1357[0], + &x64Parser::tokenBranches1349[0], + &x64Parser::tokenBranches1220[0], + &x64Parser::tokenBranches1219[0], + &x64Parser::tokenBranches3747[0], + &x64Parser::tokenBranches3756[0], + &x64Parser::tokenBranches3765[0], + &x64Parser::tokenBranches3746[0], + &x64Parser::tokenBranches3738[0], + &x64Parser::tokenBranches3875[0], + &x64Parser::tokenBranches3884[0], + &x64Parser::tokenBranches3893[0], + &x64Parser::tokenBranches3874[0], + &x64Parser::tokenBranches3866[0], + &x64Parser::tokenBranches3737[0], + &x64Parser::tokenBranches3736[0], + &x64Parser::tokenBranches4003[0], + &x64Parser::tokenBranches4012[0], + &x64Parser::tokenBranches4021[0], + &x64Parser::tokenBranches4002[0], + &x64Parser::tokenBranches3994[0], + &x64Parser::tokenBranches4131[0], + &x64Parser::tokenBranches4140[0], + &x64Parser::tokenBranches4149[0], + &x64Parser::tokenBranches4130[0], + &x64Parser::tokenBranches4122[0], + &x64Parser::tokenBranches3993[0], + &x64Parser::tokenBranches3992[0], + &x64Parser::tokenBranches7[0], + &x64Parser::tokenBranches6[0], + &x64Parser::tokenBranches13[0], + &x64Parser::tokenBranches208[0], + &x64Parser::tokenBranches354[0], + &x64Parser::tokenBranches207[0], + &x64Parser::tokenBranches42[0], + &x64Parser::tokenBranches143[0], + &x64Parser::tokenBranches289[0], + &x64Parser::tokenBranches435[0], + &x64Parser::tokenBranches41[0], + &x64Parser::tokenBranches40[0], + &x64Parser::tokenBranches217[0], + &x64Parser::tokenBranches363[0], + &x64Parser::tokenBranches216[0], + &x64Parser::tokenBranches49[0], + &x64Parser::tokenBranches162[0], + &x64Parser::tokenBranches308[0], + &x64Parser::tokenBranches454[0], + &x64Parser::tokenBranches48[0], + &x64Parser::tokenBranches47[0], + &x64Parser::tokenBranches263[0], + &x64Parser::tokenBranches409[0], + &x64Parser::tokenBranches262[0], + &x64Parser::tokenBranches83[0], + &x64Parser::tokenBranches591[0], + &x64Parser::tokenBranches715[0], + &x64Parser::tokenBranches839[0], + &x64Parser::tokenBranches2160[0], + &x64Parser::tokenBranches2719[0], + &x64Parser::tokenBranches2990[0], + &x64Parser::tokenBranches2159[0], + &x64Parser::tokenBranches2158[0], + &x64Parser::tokenBranches2157[0], + &x64Parser::tokenBranches2169[0], + &x64Parser::tokenBranches2728[0], + &x64Parser::tokenBranches2999[0], + &x64Parser::tokenBranches2168[0], + &x64Parser::tokenBranches2156[0], + &x64Parser::tokenBranches590[0], + &x64Parser::tokenBranches515[0], + &x64Parser::tokenBranches598[0], + &x64Parser::tokenBranches722[0], + &x64Parser::tokenBranches846[0], + &x64Parser::tokenBranches2140[0], + &x64Parser::tokenBranches2699[0], + &x64Parser::tokenBranches2970[0], + &x64Parser::tokenBranches2139[0], + &x64Parser::tokenBranches2138[0], + &x64Parser::tokenBranches2137[0], + &x64Parser::tokenBranches2149[0], + &x64Parser::tokenBranches2708[0], + &x64Parser::tokenBranches2979[0], + &x64Parser::tokenBranches2148[0], + &x64Parser::tokenBranches2136[0], + &x64Parser::tokenBranches2227[0], + &x64Parser::tokenBranches2639[0], + &x64Parser::tokenBranches3017[0], + &x64Parser::tokenBranches2226[0], + &x64Parser::tokenBranches2225[0], + &x64Parser::tokenBranches597[0], + &x64Parser::tokenBranches1008[0], + &x64Parser::tokenBranches1017[0], + &x64Parser::tokenBranches1026[0], + &x64Parser::tokenBranches1007[0], + &x64Parser::tokenBranches999[0], + &x64Parser::tokenBranches1136[0], + &x64Parser::tokenBranches1145[0], + &x64Parser::tokenBranches1154[0], + &x64Parser::tokenBranches1135[0], + &x64Parser::tokenBranches1127[0], + &x64Parser::tokenBranches1504[0], + &x64Parser::tokenBranches1513[0], + &x64Parser::tokenBranches1503[0], + &x64Parser::tokenBranches1495[0], + &x64Parser::tokenBranches998[0], + &x64Parser::tokenBranches520[0], + &x64Parser::tokenBranches668[0], + &x64Parser::tokenBranches792[0], + &x64Parser::tokenBranches916[0], + &x64Parser::tokenBranches667[0], + &x64Parser::tokenBranches544[0], + &x64Parser::tokenBranches659[0], + &x64Parser::tokenBranches783[0], + &x64Parser::tokenBranches907[0], + &x64Parser::tokenBranches2319[0], + &x64Parser::tokenBranches2851[0], + &x64Parser::tokenBranches3149[0], + &x64Parser::tokenBranches2318[0], + &x64Parser::tokenBranches2317[0], + &x64Parser::tokenBranches2316[0], + &x64Parser::tokenBranches2328[0], + &x64Parser::tokenBranches2860[0], + &x64Parser::tokenBranches3158[0], + &x64Parser::tokenBranches2327[0], + &x64Parser::tokenBranches2315[0], + &x64Parser::tokenBranches543[0], + &x64Parser::tokenBranches1658[0], + &x64Parser::tokenBranches1667[0], + &x64Parser::tokenBranches1676[0], + &x64Parser::tokenBranches1657[0], + &x64Parser::tokenBranches1649[0], + &x64Parser::tokenBranches1786[0], + &x64Parser::tokenBranches1795[0], + &x64Parser::tokenBranches1804[0], + &x64Parser::tokenBranches1785[0], + &x64Parser::tokenBranches1777[0], + &x64Parser::tokenBranches1954[0], + &x64Parser::tokenBranches1963[0], + &x64Parser::tokenBranches1983[0], + &x64Parser::tokenBranches1994[0], + &x64Parser::tokenBranches1982[0], + &x64Parser::tokenBranches1972[0], + &x64Parser::tokenBranches1953[0], + &x64Parser::tokenBranches1945[0], + &x64Parser::tokenBranches1648[0], + &x64Parser::tokenBranches530[0], + &x64Parser::tokenBranches569[0], + &x64Parser::tokenBranches1264[0], + &x64Parser::tokenBranches1273[0], + &x64Parser::tokenBranches1282[0], + &x64Parser::tokenBranches1263[0], + &x64Parser::tokenBranches1255[0], + &x64Parser::tokenBranches1392[0], + &x64Parser::tokenBranches1401[0], + &x64Parser::tokenBranches1410[0], + &x64Parser::tokenBranches1391[0], + &x64Parser::tokenBranches1383[0], + &x64Parser::tokenBranches1254[0], + &x64Parser::tokenBranches1253[0], + &x64Parser::tokenBranches3781[0], + &x64Parser::tokenBranches3790[0], + &x64Parser::tokenBranches3799[0], + &x64Parser::tokenBranches3780[0], + &x64Parser::tokenBranches3772[0], + &x64Parser::tokenBranches3909[0], + &x64Parser::tokenBranches3918[0], + &x64Parser::tokenBranches3927[0], + &x64Parser::tokenBranches3908[0], + &x64Parser::tokenBranches3900[0], + &x64Parser::tokenBranches3771[0], + &x64Parser::tokenBranches3770[0], + &x64Parser::tokenBranches4037[0], + &x64Parser::tokenBranches4046[0], + &x64Parser::tokenBranches4055[0], + &x64Parser::tokenBranches4036[0], + &x64Parser::tokenBranches4028[0], + &x64Parser::tokenBranches4165[0], + &x64Parser::tokenBranches4174[0], + &x64Parser::tokenBranches4183[0], + &x64Parser::tokenBranches4164[0], + &x64Parser::tokenBranches4156[0], + &x64Parser::tokenBranches4027[0], + &x64Parser::tokenBranches4026[0], + &x64Parser::tokenBranches12[0], + &x64Parser::tokenBranches11[0], + &x64Parser::tokenBranches18[0], + &x64Parser::tokenBranches235[0], + &x64Parser::tokenBranches381[0], + &x64Parser::tokenBranches234[0], + &x64Parser::tokenBranches63[0], + &x64Parser::tokenBranches150[0], + &x64Parser::tokenBranches296[0], + &x64Parser::tokenBranches442[0], + &x64Parser::tokenBranches62[0], + &x64Parser::tokenBranches61[0], + &x64Parser::tokenBranches244[0], + &x64Parser::tokenBranches390[0], + &x64Parser::tokenBranches243[0], + &x64Parser::tokenBranches70[0], + &x64Parser::tokenBranches176[0], + &x64Parser::tokenBranches322[0], + &x64Parser::tokenBranches468[0], + &x64Parser::tokenBranches69[0], + &x64Parser::tokenBranches68[0], + &x64Parser::tokenBranches270[0], + &x64Parser::tokenBranches416[0], + &x64Parser::tokenBranches269[0], + &x64Parser::tokenBranches88[0], + &x64Parser::tokenBranches729[0], + &x64Parser::tokenBranches853[0], + &x64Parser::tokenBranches2200[0], + &x64Parser::tokenBranches2759[0], + &x64Parser::tokenBranches3057[0], + &x64Parser::tokenBranches2199[0], + &x64Parser::tokenBranches2198[0], + &x64Parser::tokenBranches2197[0], + &x64Parser::tokenBranches2209[0], + &x64Parser::tokenBranches2768[0], + &x64Parser::tokenBranches3066[0], + &x64Parser::tokenBranches2208[0], + &x64Parser::tokenBranches2196[0], + &x64Parser::tokenBranches728[0], + &x64Parser::tokenBranches490[0], + &x64Parser::tokenBranches736[0], + &x64Parser::tokenBranches860[0], + &x64Parser::tokenBranches2180[0], + &x64Parser::tokenBranches2739[0], + &x64Parser::tokenBranches3037[0], + &x64Parser::tokenBranches2179[0], + &x64Parser::tokenBranches2178[0], + &x64Parser::tokenBranches2177[0], + &x64Parser::tokenBranches2189[0], + &x64Parser::tokenBranches2748[0], + &x64Parser::tokenBranches3046[0], + &x64Parser::tokenBranches2188[0], + &x64Parser::tokenBranches2176[0], + &x64Parser::tokenBranches2236[0], + &x64Parser::tokenBranches2648[0], + &x64Parser::tokenBranches3026[0], + &x64Parser::tokenBranches2235[0], + &x64Parser::tokenBranches2234[0], + &x64Parser::tokenBranches735[0], + &x64Parser::tokenBranches1042[0], + &x64Parser::tokenBranches1051[0], + &x64Parser::tokenBranches1060[0], + &x64Parser::tokenBranches1041[0], + &x64Parser::tokenBranches1033[0], + &x64Parser::tokenBranches1170[0], + &x64Parser::tokenBranches1179[0], + &x64Parser::tokenBranches1188[0], + &x64Parser::tokenBranches1169[0], + &x64Parser::tokenBranches1161[0], + &x64Parser::tokenBranches1529[0], + &x64Parser::tokenBranches1538[0], + &x64Parser::tokenBranches1528[0], + &x64Parser::tokenBranches1520[0], + &x64Parser::tokenBranches1032[0], + &x64Parser::tokenBranches495[0], + &x64Parser::tokenBranches636[0], + &x64Parser::tokenBranches760[0], + &x64Parser::tokenBranches884[0], + &x64Parser::tokenBranches2279[0], + &x64Parser::tokenBranches2811[0], + &x64Parser::tokenBranches3109[0], + &x64Parser::tokenBranches2278[0], + &x64Parser::tokenBranches2277[0], + &x64Parser::tokenBranches2276[0], + &x64Parser::tokenBranches2288[0], + &x64Parser::tokenBranches2820[0], + &x64Parser::tokenBranches3118[0], + &x64Parser::tokenBranches2287[0], + &x64Parser::tokenBranches2275[0], + &x64Parser::tokenBranches635[0], + &x64Parser::tokenBranches1298[0], + &x64Parser::tokenBranches1307[0], + &x64Parser::tokenBranches1316[0], + &x64Parser::tokenBranches1297[0], + &x64Parser::tokenBranches1289[0], + &x64Parser::tokenBranches1426[0], + &x64Parser::tokenBranches1435[0], + &x64Parser::tokenBranches1444[0], + &x64Parser::tokenBranches1425[0], + &x64Parser::tokenBranches1417[0], + &x64Parser::tokenBranches1573[0], + &x64Parser::tokenBranches1582[0], + &x64Parser::tokenBranches1572[0], + &x64Parser::tokenBranches1564[0], + &x64Parser::tokenBranches1288[0], + &x64Parser::tokenBranches500[0], + &x64Parser::tokenBranches684[0], + &x64Parser::tokenBranches808[0], + &x64Parser::tokenBranches925[0], + &x64Parser::tokenBranches683[0], + &x64Parser::tokenBranches556[0], + &x64Parser::tokenBranches675[0], + &x64Parser::tokenBranches799[0], + &x64Parser::tokenBranches932[0], + &x64Parser::tokenBranches2339[0], + &x64Parser::tokenBranches2871[0], + &x64Parser::tokenBranches3169[0], + &x64Parser::tokenBranches2338[0], + &x64Parser::tokenBranches2337[0], + &x64Parser::tokenBranches2336[0], + &x64Parser::tokenBranches2348[0], + &x64Parser::tokenBranches2880[0], + &x64Parser::tokenBranches3178[0], + &x64Parser::tokenBranches2347[0], + &x64Parser::tokenBranches2335[0], + &x64Parser::tokenBranches555[0], + &x64Parser::tokenBranches1692[0], + &x64Parser::tokenBranches1701[0], + &x64Parser::tokenBranches1710[0], + &x64Parser::tokenBranches1691[0], + &x64Parser::tokenBranches1683[0], + &x64Parser::tokenBranches1820[0], + &x64Parser::tokenBranches1829[0], + &x64Parser::tokenBranches1838[0], + &x64Parser::tokenBranches1819[0], + &x64Parser::tokenBranches1811[0], + &x64Parser::tokenBranches2010[0], + &x64Parser::tokenBranches2019[0], + &x64Parser::tokenBranches2039[0], + &x64Parser::tokenBranches2050[0], + &x64Parser::tokenBranches2038[0], + &x64Parser::tokenBranches2028[0], + &x64Parser::tokenBranches2009[0], + &x64Parser::tokenBranches2001[0], + &x64Parser::tokenBranches1682[0], + &x64Parser::tokenBranches549[0], + &x64Parser::tokenBranches574[0], + &x64Parser::tokenBranches3276[0], + &x64Parser::tokenBranches3367[0], + &x64Parser::tokenBranches3459[0], + &x64Parser::tokenBranches4568[0], + &x64Parser::tokenBranches4944[0], + &x64Parser::tokenBranches5156[0], + &x64Parser::tokenBranches4567[0], + &x64Parser::tokenBranches4566[0], + &x64Parser::tokenBranches4565[0], + &x64Parser::tokenBranches4577[0], + &x64Parser::tokenBranches4953[0], + &x64Parser::tokenBranches5165[0], + &x64Parser::tokenBranches4576[0], + &x64Parser::tokenBranches4564[0], + &x64Parser::tokenBranches3275[0], + &x64Parser::tokenBranches3195[0], + &x64Parser::tokenBranches3336[0], + &x64Parser::tokenBranches3428[0], + &x64Parser::tokenBranches3520[0], + &x64Parser::tokenBranches3335[0], + &x64Parser::tokenBranches3235[0], + &x64Parser::tokenBranches3374[0], + &x64Parser::tokenBranches3466[0], + &x64Parser::tokenBranches4588[0], + &x64Parser::tokenBranches4964[0], + &x64Parser::tokenBranches5176[0], + &x64Parser::tokenBranches4587[0], + &x64Parser::tokenBranches4586[0], + &x64Parser::tokenBranches4585[0], + &x64Parser::tokenBranches4597[0], + &x64Parser::tokenBranches4973[0], + &x64Parser::tokenBranches5185[0], + &x64Parser::tokenBranches4596[0], + &x64Parser::tokenBranches4584[0], + &x64Parser::tokenBranches3234[0], + &x64Parser::tokenBranches3282[0], + &x64Parser::tokenBranches3571[0], + &x64Parser::tokenBranches3580[0], + &x64Parser::tokenBranches3589[0], + &x64Parser::tokenBranches3570[0], + &x64Parser::tokenBranches3562[0], + &x64Parser::tokenBranches3631[0], + &x64Parser::tokenBranches3640[0], + &x64Parser::tokenBranches3649[0], + &x64Parser::tokenBranches3630[0], + &x64Parser::tokenBranches3622[0], + &x64Parser::tokenBranches3677[0], + &x64Parser::tokenBranches3676[0], + &x64Parser::tokenBranches3668[0], + &x64Parser::tokenBranches3705[0], + &x64Parser::tokenBranches3704[0], + &x64Parser::tokenBranches3696[0], + &x64Parser::tokenBranches3561[0], + &x64Parser::tokenBranches3200[0], + &x64Parser::tokenBranches3289[0], + &x64Parser::tokenBranches3381[0], + &x64Parser::tokenBranches3473[0], + &x64Parser::tokenBranches4480[0], + &x64Parser::tokenBranches4856[0], + &x64Parser::tokenBranches5068[0], + &x64Parser::tokenBranches4479[0], + &x64Parser::tokenBranches4478[0], + &x64Parser::tokenBranches4548[0], + &x64Parser::tokenBranches4924[0], + &x64Parser::tokenBranches5136[0], + &x64Parser::tokenBranches4547[0], + &x64Parser::tokenBranches4546[0], + &x64Parser::tokenBranches4545[0], + &x64Parser::tokenBranches4557[0], + &x64Parser::tokenBranches4933[0], + &x64Parser::tokenBranches5145[0], + &x64Parser::tokenBranches4556[0], + &x64Parser::tokenBranches4544[0], + &x64Parser::tokenBranches3288[0], + &x64Parser::tokenBranches3815[0], + &x64Parser::tokenBranches3824[0], + &x64Parser::tokenBranches3833[0], + &x64Parser::tokenBranches3814[0], + &x64Parser::tokenBranches3806[0], + &x64Parser::tokenBranches3943[0], + &x64Parser::tokenBranches3952[0], + &x64Parser::tokenBranches3961[0], + &x64Parser::tokenBranches3942[0], + &x64Parser::tokenBranches3934[0], + &x64Parser::tokenBranches4245[0], + &x64Parser::tokenBranches4244[0], + &x64Parser::tokenBranches4236[0], + &x64Parser::tokenBranches3805[0], + &x64Parser::tokenBranches3205[0], + &x64Parser::tokenBranches3320[0], + &x64Parser::tokenBranches3412[0], + &x64Parser::tokenBranches3504[0], + &x64Parser::tokenBranches4489[0], + &x64Parser::tokenBranches4865[0], + &x64Parser::tokenBranches5077[0], + &x64Parser::tokenBranches4488[0], + &x64Parser::tokenBranches4487[0], + &x64Parser::tokenBranches4640[0], + &x64Parser::tokenBranches5016[0], + &x64Parser::tokenBranches5228[0], + &x64Parser::tokenBranches4639[0], + &x64Parser::tokenBranches4638[0], + &x64Parser::tokenBranches4637[0], + &x64Parser::tokenBranches4649[0], + &x64Parser::tokenBranches5025[0], + &x64Parser::tokenBranches5237[0], + &x64Parser::tokenBranches4648[0], + &x64Parser::tokenBranches4636[0], + &x64Parser::tokenBranches3319[0], + &x64Parser::tokenBranches4071[0], + &x64Parser::tokenBranches4080[0], + &x64Parser::tokenBranches4089[0], + &x64Parser::tokenBranches4070[0], + &x64Parser::tokenBranches4062[0], + &x64Parser::tokenBranches4199[0], + &x64Parser::tokenBranches4208[0], + &x64Parser::tokenBranches4217[0], + &x64Parser::tokenBranches4198[0], + &x64Parser::tokenBranches4190[0], + &x64Parser::tokenBranches4273[0], + &x64Parser::tokenBranches4272[0], + &x64Parser::tokenBranches4264[0], + &x64Parser::tokenBranches4061[0], + &x64Parser::tokenBranches3210[0], + &x64Parser::tokenBranches3345[0], + &x64Parser::tokenBranches3437[0], + &x64Parser::tokenBranches3529[0], + &x64Parser::tokenBranches3344[0], + &x64Parser::tokenBranches3242[0], + &x64Parser::tokenBranches3327[0], + &x64Parser::tokenBranches3419[0], + &x64Parser::tokenBranches3511[0], + &x64Parser::tokenBranches4660[0], + &x64Parser::tokenBranches5036[0], + &x64Parser::tokenBranches5248[0], + &x64Parser::tokenBranches4659[0], + &x64Parser::tokenBranches4658[0], + &x64Parser::tokenBranches4657[0], + &x64Parser::tokenBranches4669[0], + &x64Parser::tokenBranches5045[0], + &x64Parser::tokenBranches5257[0], + &x64Parser::tokenBranches4668[0], + &x64Parser::tokenBranches4656[0], + &x64Parser::tokenBranches3241[0], + &x64Parser::tokenBranches4315[0], + &x64Parser::tokenBranches4324[0], + &x64Parser::tokenBranches4333[0], + &x64Parser::tokenBranches4314[0], + &x64Parser::tokenBranches4306[0], + &x64Parser::tokenBranches4375[0], + &x64Parser::tokenBranches4384[0], + &x64Parser::tokenBranches4393[0], + &x64Parser::tokenBranches4374[0], + &x64Parser::tokenBranches4366[0], + &x64Parser::tokenBranches4437[0], + &x64Parser::tokenBranches4457[0], + &x64Parser::tokenBranches4456[0], + &x64Parser::tokenBranches4446[0], + &x64Parser::tokenBranches4436[0], + &x64Parser::tokenBranches4428[0], + &x64Parser::tokenBranches4305[0], + &x64Parser::tokenBranches3228[0], + &x64Parser::tokenBranches3255[0], + &x64Parser::tokenBranches17[0], + &x64Parser::tokenBranches16[0], + &x64Parser::tokenBranches183[0], + &x64Parser::tokenBranches329[0], + &x64Parser::tokenBranches182[0], + &x64Parser::tokenBranches23[0], + &x64Parser::tokenBranches129[0], + &x64Parser::tokenBranches275[0], + &x64Parser::tokenBranches421[0], + &x64Parser::tokenBranches22[0], + &x64Parser::tokenBranches21[0], + &x64Parser::tokenBranches190[0], + &x64Parser::tokenBranches336[0], + &x64Parser::tokenBranches189[0], + &x64Parser::tokenBranches28[0], + &x64Parser::tokenBranches155[0], + &x64Parser::tokenBranches301[0], + &x64Parser::tokenBranches447[0], + &x64Parser::tokenBranches27[0], + &x64Parser::tokenBranches26[0], + &x64Parser::tokenBranches249[0], + &x64Parser::tokenBranches395[0], + &x64Parser::tokenBranches248[0], + &x64Parser::tokenBranches73[0], + &x64Parser::tokenBranches579[0], + &x64Parser::tokenBranches689[0], + &x64Parser::tokenBranches813[0], + &x64Parser::tokenBranches2082[0], + &x64Parser::tokenBranches2614[0], + &x64Parser::tokenBranches2912[0], + &x64Parser::tokenBranches2081[0], + &x64Parser::tokenBranches2080[0], + &x64Parser::tokenBranches2079[0], + &x64Parser::tokenBranches2089[0], + &x64Parser::tokenBranches2621[0], + &x64Parser::tokenBranches2919[0], + &x64Parser::tokenBranches2088[0], + &x64Parser::tokenBranches2078[0], + &x64Parser::tokenBranches578[0], + &x64Parser::tokenBranches471[0], + &x64Parser::tokenBranches584[0], + &x64Parser::tokenBranches694[0], + &x64Parser::tokenBranches818[0], + &x64Parser::tokenBranches2057[0], + &x64Parser::tokenBranches2589[0], + &x64Parser::tokenBranches2887[0], + &x64Parser::tokenBranches2056[0], + &x64Parser::tokenBranches2055[0], + &x64Parser::tokenBranches2066[0], + &x64Parser::tokenBranches2598[0], + &x64Parser::tokenBranches2896[0], + &x64Parser::tokenBranches2065[0], + &x64Parser::tokenBranches2064[0], + &x64Parser::tokenBranches2063[0], + &x64Parser::tokenBranches2073[0], + &x64Parser::tokenBranches2605[0], + &x64Parser::tokenBranches2903[0], + &x64Parser::tokenBranches2072[0], + &x64Parser::tokenBranches2062[0], + &x64Parser::tokenBranches583[0], + &x64Parser::tokenBranches944[0], + &x64Parser::tokenBranches951[0], + &x64Parser::tokenBranches958[0], + &x64Parser::tokenBranches943[0], + &x64Parser::tokenBranches937[0], + &x64Parser::tokenBranches1072[0], + &x64Parser::tokenBranches1079[0], + &x64Parser::tokenBranches1086[0], + &x64Parser::tokenBranches1071[0], + &x64Parser::tokenBranches1065[0], + &x64Parser::tokenBranches1456[0], + &x64Parser::tokenBranches1463[0], + &x64Parser::tokenBranches1455[0], + &x64Parser::tokenBranches1449[0], + &x64Parser::tokenBranches936[0], + &x64Parser::tokenBranches474[0], + &x64Parser::tokenBranches617[0], + &x64Parser::tokenBranches741[0], + &x64Parser::tokenBranches865[0], + &x64Parser::tokenBranches2245[0], + &x64Parser::tokenBranches2777[0], + &x64Parser::tokenBranches3075[0], + &x64Parser::tokenBranches2244[0], + &x64Parser::tokenBranches2243[0], + &x64Parser::tokenBranches2242[0], + &x64Parser::tokenBranches2252[0], + &x64Parser::tokenBranches2784[0], + &x64Parser::tokenBranches3082[0], + &x64Parser::tokenBranches2251[0], + &x64Parser::tokenBranches2241[0], + &x64Parser::tokenBranches616[0], + &x64Parser::tokenBranches1200[0], + &x64Parser::tokenBranches1207[0], + &x64Parser::tokenBranches1214[0], + &x64Parser::tokenBranches1199[0], + &x64Parser::tokenBranches1193[0], + &x64Parser::tokenBranches1328[0], + &x64Parser::tokenBranches1335[0], + &x64Parser::tokenBranches1342[0], + &x64Parser::tokenBranches1327[0], + &x64Parser::tokenBranches1321[0], + &x64Parser::tokenBranches1550[0], + &x64Parser::tokenBranches1557[0], + &x64Parser::tokenBranches1549[0], + &x64Parser::tokenBranches1543[0], + &x64Parser::tokenBranches1192[0], + &x64Parser::tokenBranches477[0], + &x64Parser::tokenBranches629[0], + &x64Parser::tokenBranches753[0], + &x64Parser::tokenBranches877[0], + &x64Parser::tokenBranches628[0], + &x64Parser::tokenBranches485[0], + &x64Parser::tokenBranches622[0], + &x64Parser::tokenBranches746[0], + &x64Parser::tokenBranches870[0], + &x64Parser::tokenBranches2261[0], + &x64Parser::tokenBranches2793[0], + &x64Parser::tokenBranches3091[0], + &x64Parser::tokenBranches2260[0], + &x64Parser::tokenBranches2259[0], + &x64Parser::tokenBranches2258[0], + &x64Parser::tokenBranches2268[0], + &x64Parser::tokenBranches2800[0], + &x64Parser::tokenBranches3098[0], + &x64Parser::tokenBranches2267[0], + &x64Parser::tokenBranches2257[0], + &x64Parser::tokenBranches484[0], + &x64Parser::tokenBranches1594[0], + &x64Parser::tokenBranches1601[0], + &x64Parser::tokenBranches1608[0], + &x64Parser::tokenBranches1593[0], + &x64Parser::tokenBranches1587[0], + &x64Parser::tokenBranches1722[0], + &x64Parser::tokenBranches1729[0], + &x64Parser::tokenBranches1736[0], + &x64Parser::tokenBranches1721[0], + &x64Parser::tokenBranches1715[0], + &x64Parser::tokenBranches1850[0], + &x64Parser::tokenBranches1857[0], + &x64Parser::tokenBranches1873[0], + &x64Parser::tokenBranches1882[0], + &x64Parser::tokenBranches1872[0], + &x64Parser::tokenBranches1864[0], + &x64Parser::tokenBranches1849[0], + &x64Parser::tokenBranches1843[0], + &x64Parser::tokenBranches1586[0], + &x64Parser::tokenBranches480[0], + &x64Parser::tokenBranches559[0], + &x64Parser::tokenBranches3260[0], + &x64Parser::tokenBranches3350[0], + &x64Parser::tokenBranches3442[0], + &x64Parser::tokenBranches4514[0], + &x64Parser::tokenBranches4890[0], + &x64Parser::tokenBranches5102[0], + &x64Parser::tokenBranches4513[0], + &x64Parser::tokenBranches4512[0], + &x64Parser::tokenBranches4511[0], + &x64Parser::tokenBranches4521[0], + &x64Parser::tokenBranches4897[0], + &x64Parser::tokenBranches5109[0], + &x64Parser::tokenBranches4520[0], + &x64Parser::tokenBranches4510[0], + &x64Parser::tokenBranches3259[0], + &x64Parser::tokenBranches3181[0], + &x64Parser::tokenBranches3306[0], + &x64Parser::tokenBranches3398[0], + &x64Parser::tokenBranches3490[0], + &x64Parser::tokenBranches3305[0], + &x64Parser::tokenBranches3218[0], + &x64Parser::tokenBranches3355[0], + &x64Parser::tokenBranches3447[0], + &x64Parser::tokenBranches4530[0], + &x64Parser::tokenBranches4906[0], + &x64Parser::tokenBranches5118[0], + &x64Parser::tokenBranches4529[0], + &x64Parser::tokenBranches4528[0], + &x64Parser::tokenBranches4527[0], + &x64Parser::tokenBranches4537[0], + &x64Parser::tokenBranches4913[0], + &x64Parser::tokenBranches5125[0], + &x64Parser::tokenBranches4536[0], + &x64Parser::tokenBranches4526[0], + &x64Parser::tokenBranches3217[0], + &x64Parser::tokenBranches3264[0], + &x64Parser::tokenBranches3541[0], + &x64Parser::tokenBranches3548[0], + &x64Parser::tokenBranches3555[0], + &x64Parser::tokenBranches3540[0], + &x64Parser::tokenBranches3534[0], + &x64Parser::tokenBranches3601[0], + &x64Parser::tokenBranches3608[0], + &x64Parser::tokenBranches3615[0], + &x64Parser::tokenBranches3600[0], + &x64Parser::tokenBranches3594[0], + &x64Parser::tokenBranches3661[0], + &x64Parser::tokenBranches3660[0], + &x64Parser::tokenBranches3654[0], + &x64Parser::tokenBranches3689[0], + &x64Parser::tokenBranches3688[0], + &x64Parser::tokenBranches3682[0], + &x64Parser::tokenBranches3533[0], + &x64Parser::tokenBranches3184[0], + &x64Parser::tokenBranches3269[0], + &x64Parser::tokenBranches3360[0], + &x64Parser::tokenBranches3452[0], + &x64Parser::tokenBranches4464[0], + &x64Parser::tokenBranches4840[0], + &x64Parser::tokenBranches5052[0], + &x64Parser::tokenBranches4463[0], + &x64Parser::tokenBranches4462[0], + &x64Parser::tokenBranches4498[0], + &x64Parser::tokenBranches4874[0], + &x64Parser::tokenBranches5086[0], + &x64Parser::tokenBranches4497[0], + &x64Parser::tokenBranches4496[0], + &x64Parser::tokenBranches4495[0], + &x64Parser::tokenBranches4505[0], + &x64Parser::tokenBranches4881[0], + &x64Parser::tokenBranches5093[0], + &x64Parser::tokenBranches4504[0], + &x64Parser::tokenBranches4494[0], + &x64Parser::tokenBranches3268[0], + &x64Parser::tokenBranches3717[0], + &x64Parser::tokenBranches3724[0], + &x64Parser::tokenBranches3731[0], + &x64Parser::tokenBranches3716[0], + &x64Parser::tokenBranches3710[0], + &x64Parser::tokenBranches3845[0], + &x64Parser::tokenBranches3852[0], + &x64Parser::tokenBranches3859[0], + &x64Parser::tokenBranches3844[0], + &x64Parser::tokenBranches3838[0], + &x64Parser::tokenBranches4229[0], + &x64Parser::tokenBranches4228[0], + &x64Parser::tokenBranches4222[0], + &x64Parser::tokenBranches3709[0], + &x64Parser::tokenBranches3187[0], + &x64Parser::tokenBranches3294[0], + &x64Parser::tokenBranches3386[0], + &x64Parser::tokenBranches3478[0], + &x64Parser::tokenBranches4471[0], + &x64Parser::tokenBranches4847[0], + &x64Parser::tokenBranches5059[0], + &x64Parser::tokenBranches4470[0], + &x64Parser::tokenBranches4469[0], + &x64Parser::tokenBranches4606[0], + &x64Parser::tokenBranches4982[0], + &x64Parser::tokenBranches5194[0], + &x64Parser::tokenBranches4605[0], + &x64Parser::tokenBranches4604[0], + &x64Parser::tokenBranches4603[0], + &x64Parser::tokenBranches4613[0], + &x64Parser::tokenBranches4989[0], + &x64Parser::tokenBranches5201[0], + &x64Parser::tokenBranches4612[0], + &x64Parser::tokenBranches4602[0], + &x64Parser::tokenBranches3293[0], + &x64Parser::tokenBranches3973[0], + &x64Parser::tokenBranches3980[0], + &x64Parser::tokenBranches3987[0], + &x64Parser::tokenBranches3972[0], + &x64Parser::tokenBranches3966[0], + &x64Parser::tokenBranches4101[0], + &x64Parser::tokenBranches4108[0], + &x64Parser::tokenBranches4115[0], + &x64Parser::tokenBranches4100[0], + &x64Parser::tokenBranches4094[0], + &x64Parser::tokenBranches4257[0], + &x64Parser::tokenBranches4256[0], + &x64Parser::tokenBranches4250[0], + &x64Parser::tokenBranches3965[0], + &x64Parser::tokenBranches3190[0], + &x64Parser::tokenBranches3313[0], + &x64Parser::tokenBranches3405[0], + &x64Parser::tokenBranches3497[0], + &x64Parser::tokenBranches3312[0], + &x64Parser::tokenBranches3223[0], + &x64Parser::tokenBranches3299[0], + &x64Parser::tokenBranches3391[0], + &x64Parser::tokenBranches3483[0], + &x64Parser::tokenBranches4622[0], + &x64Parser::tokenBranches4998[0], + &x64Parser::tokenBranches5210[0], + &x64Parser::tokenBranches4621[0], + &x64Parser::tokenBranches4620[0], + &x64Parser::tokenBranches4619[0], + &x64Parser::tokenBranches4629[0], + &x64Parser::tokenBranches5005[0], + &x64Parser::tokenBranches5217[0], + &x64Parser::tokenBranches4628[0], + &x64Parser::tokenBranches4618[0], + &x64Parser::tokenBranches3222[0], + &x64Parser::tokenBranches4285[0], + &x64Parser::tokenBranches4292[0], + &x64Parser::tokenBranches4299[0], + &x64Parser::tokenBranches4284[0], + &x64Parser::tokenBranches4278[0], + &x64Parser::tokenBranches4345[0], + &x64Parser::tokenBranches4352[0], + &x64Parser::tokenBranches4359[0], + &x64Parser::tokenBranches4344[0], + &x64Parser::tokenBranches4338[0], + &x64Parser::tokenBranches4405[0], + &x64Parser::tokenBranches4421[0], + &x64Parser::tokenBranches4420[0], + &x64Parser::tokenBranches4412[0], + &x64Parser::tokenBranches4404[0], + &x64Parser::tokenBranches4398[0], + &x64Parser::tokenBranches4277[0], + &x64Parser::tokenBranches3213[0], + &x64Parser::tokenBranches3247[0], + &x64Parser::tokenBranches3246[0], + &x64Parser::tokenBranches3245[0], + &x64Parser::tokenBranches3250[0], + &x64Parser::tokenBranches2[0], + &x64Parser::tokenBranches1[0], }; Coding x64Parser::Coding1[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding2[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding3[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding4[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding5[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding6[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding7[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding8[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding9[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding10[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding11[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding12[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding13[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding14[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding15[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding16[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding17[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding18[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding19[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding20[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding21[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding22[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding23[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding24[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding25[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding26[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding27[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding28[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding29[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding30[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding31[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding32[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding33[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding34[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding35[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding36[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding37[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding38[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding39[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding40[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 1, 6, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding41[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding42[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding43[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 6, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding44[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding45[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding46[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding47[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding48[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding49[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding50[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding51[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding52[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding53[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding54[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding55[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding56[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding57[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding58[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding59[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding60[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding61[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding62[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding63[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding64[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding65[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding66[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding67[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding68[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding69[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding70[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding71[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding72[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding73[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding74[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding75[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding76[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding77[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding78[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding79[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding80[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding81[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding82[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding83[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding84[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding85[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding86[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding87[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding88[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding89[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding90[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding91[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding92[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding93[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding94[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding95[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding96[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding97[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding98[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding99[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding100[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding101[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding102[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding103[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding104[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding105[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding106[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding107[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding108[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding109[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding110[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding111[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding112[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding113[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding114[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding115[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding116[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding117[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding118[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding119[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding120[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding121[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding122[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding123[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding124[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding125[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding126[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding127[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding128[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding129[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding130[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding131[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding132[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding133[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding134[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding135[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding136[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding137[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding138[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding139[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding140[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding141[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding142[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding143[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding144[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding145[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding146[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding147[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding148[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding149[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding150[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding151[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding152[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding153[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding154[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding155[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding156[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding157[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding158[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding159[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding160[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding161[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding162[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding163[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding164[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding165[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 54, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding166[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding167[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding168[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding169[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding170[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding171[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding172[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding173[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding174[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding175[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding176[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding177[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding178[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding179[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding180[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding181[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding182[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding183[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding184[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding185[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding186[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding187[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding188[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding189[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding190[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding191[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding192[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding193[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding194[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding195[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding196[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding197[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding198[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding199[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding200[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding201[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding202[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding203[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding204[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding205[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding206[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding207[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding208[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding209[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding210[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding211[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding212[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding213[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding214[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding215[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding216[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding217[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding218[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding219[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding220[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding221[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding222[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding223[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding224[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding225[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding226[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding227[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding228[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding229[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 62, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding230[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding231[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding232[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding233[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding234[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding235[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding236[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding237[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding238[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding239[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 1057, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 1057, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding240[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding241[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding242[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 54, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding243[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding244[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding245[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding246[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding247[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding248[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding249[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding250[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding251[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding252[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding253[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding254[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding255[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding256[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding257[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding258[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding259[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding260[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding261[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding262[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding263[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding264[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding265[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding266[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding267[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding268[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding269[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding270[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding271[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding272[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding273[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding274[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding275[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding276[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding277[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding278[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding279[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding280[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding281[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding282[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding283[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding284[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding285[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding286[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding287[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding288[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding289[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding290[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding291[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding292[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding293[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding294[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding295[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding296[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding297[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding298[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 67, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding299[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding300[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding301[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding302[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding303[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding304[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding305[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding306[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding307[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding308[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding309[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding310[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding311[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding312[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding313[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding314[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding315[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding316[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding317[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding318[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding319[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding320[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding321[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding322[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding323[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding324[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding325[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding326[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding327[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding328[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding329[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding330[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding331[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding332[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding333[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding334[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding335[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding336[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding337[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding338[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding339[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 62, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding340[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding341[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding342[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding343[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding344[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding345[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding346[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding347[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding348[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding349[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding350[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding351[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding352[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding353[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding354[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding355[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding356[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding357[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding358[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding359[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 6, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding360[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding361[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding362[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding363[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding364[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding365[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding366[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding367[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding368[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding369[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding370[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding371[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding372[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding373[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding374[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding375[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding376[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding377[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding378[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding379[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding380[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding381[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding382[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding383[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding384[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding385[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding386[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding387[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding388[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding389[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding390[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding391[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding392[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding393[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding394[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding395[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding396[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding397[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding398[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding399[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding400[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding401[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding402[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding403[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding404[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding405[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding406[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding407[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding408[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding409[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding410[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding411[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding412[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding413[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding414[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding415[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 5, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding416[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding417[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding418[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding419[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 66, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 16, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding420[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding421[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding422[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding423[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding424[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding425[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding426[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding427[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding428[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding429[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding430[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding431[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding432[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding433[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding434[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding435[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding436[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding437[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 65, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 8, 4, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 5, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding438[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 9, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding439[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 17, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 3, 0, 4, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 4, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 3, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 6, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 1, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding440[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding441[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding442[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 15, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding443[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::optional | Coding::indirect), 23, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 16, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 17, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding444[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding445[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding446[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 36, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding447[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding448[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding449[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding450[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding451[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding452[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding453[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding454[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding455[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding456[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding457[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding458[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding459[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding460[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding461[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding462[] = { - {CODING_NAME("unknown") Coding::stateFunc, 7}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 7 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 2, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 19, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding463[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding464[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 39, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 39, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 15, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding465[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect), 19, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 18, 3, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding466[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding467[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding468[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 38, 4, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding469[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 26, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 26, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding470[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding471[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 25, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding472[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding473[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding474[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding475[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding476[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding477[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 154, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding478[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding479[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding480[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding481[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding482[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding483[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding484[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 166, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding485[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding486[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding487[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding488[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding489[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding490[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding491[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding492[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding493[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding494[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding495[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding496[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding497[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding498[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding499[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding500[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding501[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 167, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding502[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding503[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding504[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding505[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding506[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding507[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding508[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding509[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding510[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding511[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding512[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding513[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding514[] = { - {Coding::native}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { Coding::native }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding515[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding516[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding517[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding518[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding519[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding520[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding521[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding522[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding523[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding524[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding525[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding526[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding527[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding528[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding529[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding530[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding531[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding532[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding533[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding534[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding535[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding536[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding537[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding538[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding539[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding540[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding541[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding542[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding543[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding544[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding545[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding546[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding547[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding548[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding549[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding550[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding551[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding552[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding553[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding554[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding555[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding556[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding557[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding558[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding559[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding560[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding561[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding562[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding563[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding564[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding565[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding566[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding567[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding568[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding569[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding570[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding571[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding572[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding573[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding574[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding575[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding576[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding577[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding578[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding579[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding580[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding581[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding582[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding583[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding584[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding585[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding586[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding587[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding588[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding589[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding590[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding591[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding592[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding593[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding594[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 23, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding595[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding596[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding597[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding598[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding599[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding600[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding601[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding602[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding603[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding604[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding605[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding606[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 163, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding607[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding608[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding609[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding610[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding611[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding612[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding613[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding614[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding615[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding616[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding617[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding618[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding619[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding620[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding621[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding622[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding623[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding624[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding625[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding626[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding627[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding628[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding629[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding630[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding631[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding632[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding633[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding634[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding635[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding636[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding637[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding638[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding639[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding640[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding641[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding642[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding643[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding644[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding645[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding646[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding647[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding648[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding649[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding650[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding651[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding652[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding653[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding654[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding655[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding656[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding657[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding658[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding659[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding660[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding661[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding662[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding663[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding664[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding665[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding666[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding667[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding668[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {Coding::native}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding669[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {Coding::native}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding670[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding671[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding672[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding673[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding674[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding675[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding676[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding677[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding678[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding679[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding680[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding681[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding682[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding683[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding684[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding685[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding686[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding687[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding688[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding689[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding690[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding691[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding692[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding693[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding694[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding695[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding696[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding697[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding698[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding699[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding700[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding701[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding702[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding703[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding704[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding705[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding706[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding707[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding708[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding709[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding710[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding711[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding712[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding713[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding714[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding715[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding716[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding717[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding718[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding719[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding720[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding721[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding722[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding723[] = { - {CODING_NAME("unknown") Coding::stateFunc, 4}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 4 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding724[] = { - {CODING_NAME("unknown") Coding::stateFunc, 5}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 5 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding725[] = { - {CODING_NAME("unknown") Coding::stateFunc, 6}, - {CODING_NAME("unknown")(Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+'}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 6 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 5, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding726[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding727[] = { - {CODING_NAME("unknown") Coding::stateFunc, 1}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 1 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding728[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding729[] = { - {CODING_NAME("unknown") Coding::stateFunc, 2}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 2 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding730[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding731[] = { - {CODING_NAME("unknown") Coding::stateFunc, 3}, - {CODING_NAME("unknown")(Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("unknown") Coding::stateFunc, 3 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding732[] = { - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0}, - {CODING_NAME("unknown")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::Codings[732] = { - x64Parser::Coding1, x64Parser::Coding2, x64Parser::Coding3, x64Parser::Coding4, x64Parser::Coding5, - x64Parser::Coding6, x64Parser::Coding7, x64Parser::Coding8, x64Parser::Coding9, x64Parser::Coding10, - x64Parser::Coding11, x64Parser::Coding12, x64Parser::Coding13, x64Parser::Coding14, x64Parser::Coding15, - x64Parser::Coding16, x64Parser::Coding17, x64Parser::Coding18, x64Parser::Coding19, x64Parser::Coding20, - x64Parser::Coding21, x64Parser::Coding22, x64Parser::Coding23, x64Parser::Coding24, x64Parser::Coding25, - x64Parser::Coding26, x64Parser::Coding27, x64Parser::Coding28, x64Parser::Coding29, x64Parser::Coding30, - x64Parser::Coding31, x64Parser::Coding32, x64Parser::Coding33, x64Parser::Coding34, x64Parser::Coding35, - x64Parser::Coding36, x64Parser::Coding37, x64Parser::Coding38, x64Parser::Coding39, x64Parser::Coding40, - x64Parser::Coding41, x64Parser::Coding42, x64Parser::Coding43, x64Parser::Coding44, x64Parser::Coding45, - x64Parser::Coding46, x64Parser::Coding47, x64Parser::Coding48, x64Parser::Coding49, x64Parser::Coding50, - x64Parser::Coding51, x64Parser::Coding52, x64Parser::Coding53, x64Parser::Coding54, x64Parser::Coding55, - x64Parser::Coding56, x64Parser::Coding57, x64Parser::Coding58, x64Parser::Coding59, x64Parser::Coding60, - x64Parser::Coding61, x64Parser::Coding62, x64Parser::Coding63, x64Parser::Coding64, x64Parser::Coding65, - x64Parser::Coding66, x64Parser::Coding67, x64Parser::Coding68, x64Parser::Coding69, x64Parser::Coding70, - x64Parser::Coding71, x64Parser::Coding72, x64Parser::Coding73, x64Parser::Coding74, x64Parser::Coding75, - x64Parser::Coding76, x64Parser::Coding77, x64Parser::Coding78, x64Parser::Coding79, x64Parser::Coding80, - x64Parser::Coding81, x64Parser::Coding82, x64Parser::Coding83, x64Parser::Coding84, x64Parser::Coding85, - x64Parser::Coding86, x64Parser::Coding87, x64Parser::Coding88, x64Parser::Coding89, x64Parser::Coding90, - x64Parser::Coding91, x64Parser::Coding92, x64Parser::Coding93, x64Parser::Coding94, x64Parser::Coding95, - x64Parser::Coding96, x64Parser::Coding97, x64Parser::Coding98, x64Parser::Coding99, x64Parser::Coding100, - x64Parser::Coding101, x64Parser::Coding102, x64Parser::Coding103, x64Parser::Coding104, x64Parser::Coding105, - x64Parser::Coding106, x64Parser::Coding107, x64Parser::Coding108, x64Parser::Coding109, x64Parser::Coding110, - x64Parser::Coding111, x64Parser::Coding112, x64Parser::Coding113, x64Parser::Coding114, x64Parser::Coding115, - x64Parser::Coding116, x64Parser::Coding117, x64Parser::Coding118, x64Parser::Coding119, x64Parser::Coding120, - x64Parser::Coding121, x64Parser::Coding122, x64Parser::Coding123, x64Parser::Coding124, x64Parser::Coding125, - x64Parser::Coding126, x64Parser::Coding127, x64Parser::Coding128, x64Parser::Coding129, x64Parser::Coding130, - x64Parser::Coding131, x64Parser::Coding132, x64Parser::Coding133, x64Parser::Coding134, x64Parser::Coding135, - x64Parser::Coding136, x64Parser::Coding137, x64Parser::Coding138, x64Parser::Coding139, x64Parser::Coding140, - x64Parser::Coding141, x64Parser::Coding142, x64Parser::Coding143, x64Parser::Coding144, x64Parser::Coding145, - x64Parser::Coding146, x64Parser::Coding147, x64Parser::Coding148, x64Parser::Coding149, x64Parser::Coding150, - x64Parser::Coding151, x64Parser::Coding152, x64Parser::Coding153, x64Parser::Coding154, x64Parser::Coding155, - x64Parser::Coding156, x64Parser::Coding157, x64Parser::Coding158, x64Parser::Coding159, x64Parser::Coding160, - x64Parser::Coding161, x64Parser::Coding162, x64Parser::Coding163, x64Parser::Coding164, x64Parser::Coding165, - x64Parser::Coding166, x64Parser::Coding167, x64Parser::Coding168, x64Parser::Coding169, x64Parser::Coding170, - x64Parser::Coding171, x64Parser::Coding172, x64Parser::Coding173, x64Parser::Coding174, x64Parser::Coding175, - x64Parser::Coding176, x64Parser::Coding177, x64Parser::Coding178, x64Parser::Coding179, x64Parser::Coding180, - x64Parser::Coding181, x64Parser::Coding182, x64Parser::Coding183, x64Parser::Coding184, x64Parser::Coding185, - x64Parser::Coding186, x64Parser::Coding187, x64Parser::Coding188, x64Parser::Coding189, x64Parser::Coding190, - x64Parser::Coding191, x64Parser::Coding192, x64Parser::Coding193, x64Parser::Coding194, x64Parser::Coding195, - x64Parser::Coding196, x64Parser::Coding197, x64Parser::Coding198, x64Parser::Coding199, x64Parser::Coding200, - x64Parser::Coding201, x64Parser::Coding202, x64Parser::Coding203, x64Parser::Coding204, x64Parser::Coding205, - x64Parser::Coding206, x64Parser::Coding207, x64Parser::Coding208, x64Parser::Coding209, x64Parser::Coding210, - x64Parser::Coding211, x64Parser::Coding212, x64Parser::Coding213, x64Parser::Coding214, x64Parser::Coding215, - x64Parser::Coding216, x64Parser::Coding217, x64Parser::Coding218, x64Parser::Coding219, x64Parser::Coding220, - x64Parser::Coding221, x64Parser::Coding222, x64Parser::Coding223, x64Parser::Coding224, x64Parser::Coding225, - x64Parser::Coding226, x64Parser::Coding227, x64Parser::Coding228, x64Parser::Coding229, x64Parser::Coding230, - x64Parser::Coding231, x64Parser::Coding232, x64Parser::Coding233, x64Parser::Coding234, x64Parser::Coding235, - x64Parser::Coding236, x64Parser::Coding237, x64Parser::Coding238, x64Parser::Coding239, x64Parser::Coding240, - x64Parser::Coding241, x64Parser::Coding242, x64Parser::Coding243, x64Parser::Coding244, x64Parser::Coding245, - x64Parser::Coding246, x64Parser::Coding247, x64Parser::Coding248, x64Parser::Coding249, x64Parser::Coding250, - x64Parser::Coding251, x64Parser::Coding252, x64Parser::Coding253, x64Parser::Coding254, x64Parser::Coding255, - x64Parser::Coding256, x64Parser::Coding257, x64Parser::Coding258, x64Parser::Coding259, x64Parser::Coding260, - x64Parser::Coding261, x64Parser::Coding262, x64Parser::Coding263, x64Parser::Coding264, x64Parser::Coding265, - x64Parser::Coding266, x64Parser::Coding267, x64Parser::Coding268, x64Parser::Coding269, x64Parser::Coding270, - x64Parser::Coding271, x64Parser::Coding272, x64Parser::Coding273, x64Parser::Coding274, x64Parser::Coding275, - x64Parser::Coding276, x64Parser::Coding277, x64Parser::Coding278, x64Parser::Coding279, x64Parser::Coding280, - x64Parser::Coding281, x64Parser::Coding282, x64Parser::Coding283, x64Parser::Coding284, x64Parser::Coding285, - x64Parser::Coding286, x64Parser::Coding287, x64Parser::Coding288, x64Parser::Coding289, x64Parser::Coding290, - x64Parser::Coding291, x64Parser::Coding292, x64Parser::Coding293, x64Parser::Coding294, x64Parser::Coding295, - x64Parser::Coding296, x64Parser::Coding297, x64Parser::Coding298, x64Parser::Coding299, x64Parser::Coding300, - x64Parser::Coding301, x64Parser::Coding302, x64Parser::Coding303, x64Parser::Coding304, x64Parser::Coding305, - x64Parser::Coding306, x64Parser::Coding307, x64Parser::Coding308, x64Parser::Coding309, x64Parser::Coding310, - x64Parser::Coding311, x64Parser::Coding312, x64Parser::Coding313, x64Parser::Coding314, x64Parser::Coding315, - x64Parser::Coding316, x64Parser::Coding317, x64Parser::Coding318, x64Parser::Coding319, x64Parser::Coding320, - x64Parser::Coding321, x64Parser::Coding322, x64Parser::Coding323, x64Parser::Coding324, x64Parser::Coding325, - x64Parser::Coding326, x64Parser::Coding327, x64Parser::Coding328, x64Parser::Coding329, x64Parser::Coding330, - x64Parser::Coding331, x64Parser::Coding332, x64Parser::Coding333, x64Parser::Coding334, x64Parser::Coding335, - x64Parser::Coding336, x64Parser::Coding337, x64Parser::Coding338, x64Parser::Coding339, x64Parser::Coding340, - x64Parser::Coding341, x64Parser::Coding342, x64Parser::Coding343, x64Parser::Coding344, x64Parser::Coding345, - x64Parser::Coding346, x64Parser::Coding347, x64Parser::Coding348, x64Parser::Coding349, x64Parser::Coding350, - x64Parser::Coding351, x64Parser::Coding352, x64Parser::Coding353, x64Parser::Coding354, x64Parser::Coding355, - x64Parser::Coding356, x64Parser::Coding357, x64Parser::Coding358, x64Parser::Coding359, x64Parser::Coding360, - x64Parser::Coding361, x64Parser::Coding362, x64Parser::Coding363, x64Parser::Coding364, x64Parser::Coding365, - x64Parser::Coding366, x64Parser::Coding367, x64Parser::Coding368, x64Parser::Coding369, x64Parser::Coding370, - x64Parser::Coding371, x64Parser::Coding372, x64Parser::Coding373, x64Parser::Coding374, x64Parser::Coding375, - x64Parser::Coding376, x64Parser::Coding377, x64Parser::Coding378, x64Parser::Coding379, x64Parser::Coding380, - x64Parser::Coding381, x64Parser::Coding382, x64Parser::Coding383, x64Parser::Coding384, x64Parser::Coding385, - x64Parser::Coding386, x64Parser::Coding387, x64Parser::Coding388, x64Parser::Coding389, x64Parser::Coding390, - x64Parser::Coding391, x64Parser::Coding392, x64Parser::Coding393, x64Parser::Coding394, x64Parser::Coding395, - x64Parser::Coding396, x64Parser::Coding397, x64Parser::Coding398, x64Parser::Coding399, x64Parser::Coding400, - x64Parser::Coding401, x64Parser::Coding402, x64Parser::Coding403, x64Parser::Coding404, x64Parser::Coding405, - x64Parser::Coding406, x64Parser::Coding407, x64Parser::Coding408, x64Parser::Coding409, x64Parser::Coding410, - x64Parser::Coding411, x64Parser::Coding412, x64Parser::Coding413, x64Parser::Coding414, x64Parser::Coding415, - x64Parser::Coding416, x64Parser::Coding417, x64Parser::Coding418, x64Parser::Coding419, x64Parser::Coding420, - x64Parser::Coding421, x64Parser::Coding422, x64Parser::Coding423, x64Parser::Coding424, x64Parser::Coding425, - x64Parser::Coding426, x64Parser::Coding427, x64Parser::Coding428, x64Parser::Coding429, x64Parser::Coding430, - x64Parser::Coding431, x64Parser::Coding432, x64Parser::Coding433, x64Parser::Coding434, x64Parser::Coding435, - x64Parser::Coding436, x64Parser::Coding437, x64Parser::Coding438, x64Parser::Coding439, x64Parser::Coding440, - x64Parser::Coding441, x64Parser::Coding442, x64Parser::Coding443, x64Parser::Coding444, x64Parser::Coding445, - x64Parser::Coding446, x64Parser::Coding447, x64Parser::Coding448, x64Parser::Coding449, x64Parser::Coding450, - x64Parser::Coding451, x64Parser::Coding452, x64Parser::Coding453, x64Parser::Coding454, x64Parser::Coding455, - x64Parser::Coding456, x64Parser::Coding457, x64Parser::Coding458, x64Parser::Coding459, x64Parser::Coding460, - x64Parser::Coding461, x64Parser::Coding462, x64Parser::Coding463, x64Parser::Coding464, x64Parser::Coding465, - x64Parser::Coding466, x64Parser::Coding467, x64Parser::Coding468, x64Parser::Coding469, x64Parser::Coding470, - x64Parser::Coding471, x64Parser::Coding472, x64Parser::Coding473, x64Parser::Coding474, x64Parser::Coding475, - x64Parser::Coding476, x64Parser::Coding477, x64Parser::Coding478, x64Parser::Coding479, x64Parser::Coding480, - x64Parser::Coding481, x64Parser::Coding482, x64Parser::Coding483, x64Parser::Coding484, x64Parser::Coding485, - x64Parser::Coding486, x64Parser::Coding487, x64Parser::Coding488, x64Parser::Coding489, x64Parser::Coding490, - x64Parser::Coding491, x64Parser::Coding492, x64Parser::Coding493, x64Parser::Coding494, x64Parser::Coding495, - x64Parser::Coding496, x64Parser::Coding497, x64Parser::Coding498, x64Parser::Coding499, x64Parser::Coding500, - x64Parser::Coding501, x64Parser::Coding502, x64Parser::Coding503, x64Parser::Coding504, x64Parser::Coding505, - x64Parser::Coding506, x64Parser::Coding507, x64Parser::Coding508, x64Parser::Coding509, x64Parser::Coding510, - x64Parser::Coding511, x64Parser::Coding512, x64Parser::Coding513, x64Parser::Coding514, x64Parser::Coding515, - x64Parser::Coding516, x64Parser::Coding517, x64Parser::Coding518, x64Parser::Coding519, x64Parser::Coding520, - x64Parser::Coding521, x64Parser::Coding522, x64Parser::Coding523, x64Parser::Coding524, x64Parser::Coding525, - x64Parser::Coding526, x64Parser::Coding527, x64Parser::Coding528, x64Parser::Coding529, x64Parser::Coding530, - x64Parser::Coding531, x64Parser::Coding532, x64Parser::Coding533, x64Parser::Coding534, x64Parser::Coding535, - x64Parser::Coding536, x64Parser::Coding537, x64Parser::Coding538, x64Parser::Coding539, x64Parser::Coding540, - x64Parser::Coding541, x64Parser::Coding542, x64Parser::Coding543, x64Parser::Coding544, x64Parser::Coding545, - x64Parser::Coding546, x64Parser::Coding547, x64Parser::Coding548, x64Parser::Coding549, x64Parser::Coding550, - x64Parser::Coding551, x64Parser::Coding552, x64Parser::Coding553, x64Parser::Coding554, x64Parser::Coding555, - x64Parser::Coding556, x64Parser::Coding557, x64Parser::Coding558, x64Parser::Coding559, x64Parser::Coding560, - x64Parser::Coding561, x64Parser::Coding562, x64Parser::Coding563, x64Parser::Coding564, x64Parser::Coding565, - x64Parser::Coding566, x64Parser::Coding567, x64Parser::Coding568, x64Parser::Coding569, x64Parser::Coding570, - x64Parser::Coding571, x64Parser::Coding572, x64Parser::Coding573, x64Parser::Coding574, x64Parser::Coding575, - x64Parser::Coding576, x64Parser::Coding577, x64Parser::Coding578, x64Parser::Coding579, x64Parser::Coding580, - x64Parser::Coding581, x64Parser::Coding582, x64Parser::Coding583, x64Parser::Coding584, x64Parser::Coding585, - x64Parser::Coding586, x64Parser::Coding587, x64Parser::Coding588, x64Parser::Coding589, x64Parser::Coding590, - x64Parser::Coding591, x64Parser::Coding592, x64Parser::Coding593, x64Parser::Coding594, x64Parser::Coding595, - x64Parser::Coding596, x64Parser::Coding597, x64Parser::Coding598, x64Parser::Coding599, x64Parser::Coding600, - x64Parser::Coding601, x64Parser::Coding602, x64Parser::Coding603, x64Parser::Coding604, x64Parser::Coding605, - x64Parser::Coding606, x64Parser::Coding607, x64Parser::Coding608, x64Parser::Coding609, x64Parser::Coding610, - x64Parser::Coding611, x64Parser::Coding612, x64Parser::Coding613, x64Parser::Coding614, x64Parser::Coding615, - x64Parser::Coding616, x64Parser::Coding617, x64Parser::Coding618, x64Parser::Coding619, x64Parser::Coding620, - x64Parser::Coding621, x64Parser::Coding622, x64Parser::Coding623, x64Parser::Coding624, x64Parser::Coding625, - x64Parser::Coding626, x64Parser::Coding627, x64Parser::Coding628, x64Parser::Coding629, x64Parser::Coding630, - x64Parser::Coding631, x64Parser::Coding632, x64Parser::Coding633, x64Parser::Coding634, x64Parser::Coding635, - x64Parser::Coding636, x64Parser::Coding637, x64Parser::Coding638, x64Parser::Coding639, x64Parser::Coding640, - x64Parser::Coding641, x64Parser::Coding642, x64Parser::Coding643, x64Parser::Coding644, x64Parser::Coding645, - x64Parser::Coding646, x64Parser::Coding647, x64Parser::Coding648, x64Parser::Coding649, x64Parser::Coding650, - x64Parser::Coding651, x64Parser::Coding652, x64Parser::Coding653, x64Parser::Coding654, x64Parser::Coding655, - x64Parser::Coding656, x64Parser::Coding657, x64Parser::Coding658, x64Parser::Coding659, x64Parser::Coding660, - x64Parser::Coding661, x64Parser::Coding662, x64Parser::Coding663, x64Parser::Coding664, x64Parser::Coding665, - x64Parser::Coding666, x64Parser::Coding667, x64Parser::Coding668, x64Parser::Coding669, x64Parser::Coding670, - x64Parser::Coding671, x64Parser::Coding672, x64Parser::Coding673, x64Parser::Coding674, x64Parser::Coding675, - x64Parser::Coding676, x64Parser::Coding677, x64Parser::Coding678, x64Parser::Coding679, x64Parser::Coding680, - x64Parser::Coding681, x64Parser::Coding682, x64Parser::Coding683, x64Parser::Coding684, x64Parser::Coding685, - x64Parser::Coding686, x64Parser::Coding687, x64Parser::Coding688, x64Parser::Coding689, x64Parser::Coding690, - x64Parser::Coding691, x64Parser::Coding692, x64Parser::Coding693, x64Parser::Coding694, x64Parser::Coding695, - x64Parser::Coding696, x64Parser::Coding697, x64Parser::Coding698, x64Parser::Coding699, x64Parser::Coding700, - x64Parser::Coding701, x64Parser::Coding702, x64Parser::Coding703, x64Parser::Coding704, x64Parser::Coding705, - x64Parser::Coding706, x64Parser::Coding707, x64Parser::Coding708, x64Parser::Coding709, x64Parser::Coding710, - x64Parser::Coding711, x64Parser::Coding712, x64Parser::Coding713, x64Parser::Coding714, x64Parser::Coding715, - x64Parser::Coding716, x64Parser::Coding717, x64Parser::Coding718, x64Parser::Coding719, x64Parser::Coding720, - x64Parser::Coding721, x64Parser::Coding722, x64Parser::Coding723, x64Parser::Coding724, x64Parser::Coding725, - x64Parser::Coding726, x64Parser::Coding727, x64Parser::Coding728, x64Parser::Coding729, x64Parser::Coding730, - x64Parser::Coding731, x64Parser::Coding732, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding * x64Parser::Codings[732] = { + x64Parser::Coding1, + x64Parser::Coding2, + x64Parser::Coding3, + x64Parser::Coding4, + x64Parser::Coding5, + x64Parser::Coding6, + x64Parser::Coding7, + x64Parser::Coding8, + x64Parser::Coding9, + x64Parser::Coding10, + x64Parser::Coding11, + x64Parser::Coding12, + x64Parser::Coding13, + x64Parser::Coding14, + x64Parser::Coding15, + x64Parser::Coding16, + x64Parser::Coding17, + x64Parser::Coding18, + x64Parser::Coding19, + x64Parser::Coding20, + x64Parser::Coding21, + x64Parser::Coding22, + x64Parser::Coding23, + x64Parser::Coding24, + x64Parser::Coding25, + x64Parser::Coding26, + x64Parser::Coding27, + x64Parser::Coding28, + x64Parser::Coding29, + x64Parser::Coding30, + x64Parser::Coding31, + x64Parser::Coding32, + x64Parser::Coding33, + x64Parser::Coding34, + x64Parser::Coding35, + x64Parser::Coding36, + x64Parser::Coding37, + x64Parser::Coding38, + x64Parser::Coding39, + x64Parser::Coding40, + x64Parser::Coding41, + x64Parser::Coding42, + x64Parser::Coding43, + x64Parser::Coding44, + x64Parser::Coding45, + x64Parser::Coding46, + x64Parser::Coding47, + x64Parser::Coding48, + x64Parser::Coding49, + x64Parser::Coding50, + x64Parser::Coding51, + x64Parser::Coding52, + x64Parser::Coding53, + x64Parser::Coding54, + x64Parser::Coding55, + x64Parser::Coding56, + x64Parser::Coding57, + x64Parser::Coding58, + x64Parser::Coding59, + x64Parser::Coding60, + x64Parser::Coding61, + x64Parser::Coding62, + x64Parser::Coding63, + x64Parser::Coding64, + x64Parser::Coding65, + x64Parser::Coding66, + x64Parser::Coding67, + x64Parser::Coding68, + x64Parser::Coding69, + x64Parser::Coding70, + x64Parser::Coding71, + x64Parser::Coding72, + x64Parser::Coding73, + x64Parser::Coding74, + x64Parser::Coding75, + x64Parser::Coding76, + x64Parser::Coding77, + x64Parser::Coding78, + x64Parser::Coding79, + x64Parser::Coding80, + x64Parser::Coding81, + x64Parser::Coding82, + x64Parser::Coding83, + x64Parser::Coding84, + x64Parser::Coding85, + x64Parser::Coding86, + x64Parser::Coding87, + x64Parser::Coding88, + x64Parser::Coding89, + x64Parser::Coding90, + x64Parser::Coding91, + x64Parser::Coding92, + x64Parser::Coding93, + x64Parser::Coding94, + x64Parser::Coding95, + x64Parser::Coding96, + x64Parser::Coding97, + x64Parser::Coding98, + x64Parser::Coding99, + x64Parser::Coding100, + x64Parser::Coding101, + x64Parser::Coding102, + x64Parser::Coding103, + x64Parser::Coding104, + x64Parser::Coding105, + x64Parser::Coding106, + x64Parser::Coding107, + x64Parser::Coding108, + x64Parser::Coding109, + x64Parser::Coding110, + x64Parser::Coding111, + x64Parser::Coding112, + x64Parser::Coding113, + x64Parser::Coding114, + x64Parser::Coding115, + x64Parser::Coding116, + x64Parser::Coding117, + x64Parser::Coding118, + x64Parser::Coding119, + x64Parser::Coding120, + x64Parser::Coding121, + x64Parser::Coding122, + x64Parser::Coding123, + x64Parser::Coding124, + x64Parser::Coding125, + x64Parser::Coding126, + x64Parser::Coding127, + x64Parser::Coding128, + x64Parser::Coding129, + x64Parser::Coding130, + x64Parser::Coding131, + x64Parser::Coding132, + x64Parser::Coding133, + x64Parser::Coding134, + x64Parser::Coding135, + x64Parser::Coding136, + x64Parser::Coding137, + x64Parser::Coding138, + x64Parser::Coding139, + x64Parser::Coding140, + x64Parser::Coding141, + x64Parser::Coding142, + x64Parser::Coding143, + x64Parser::Coding144, + x64Parser::Coding145, + x64Parser::Coding146, + x64Parser::Coding147, + x64Parser::Coding148, + x64Parser::Coding149, + x64Parser::Coding150, + x64Parser::Coding151, + x64Parser::Coding152, + x64Parser::Coding153, + x64Parser::Coding154, + x64Parser::Coding155, + x64Parser::Coding156, + x64Parser::Coding157, + x64Parser::Coding158, + x64Parser::Coding159, + x64Parser::Coding160, + x64Parser::Coding161, + x64Parser::Coding162, + x64Parser::Coding163, + x64Parser::Coding164, + x64Parser::Coding165, + x64Parser::Coding166, + x64Parser::Coding167, + x64Parser::Coding168, + x64Parser::Coding169, + x64Parser::Coding170, + x64Parser::Coding171, + x64Parser::Coding172, + x64Parser::Coding173, + x64Parser::Coding174, + x64Parser::Coding175, + x64Parser::Coding176, + x64Parser::Coding177, + x64Parser::Coding178, + x64Parser::Coding179, + x64Parser::Coding180, + x64Parser::Coding181, + x64Parser::Coding182, + x64Parser::Coding183, + x64Parser::Coding184, + x64Parser::Coding185, + x64Parser::Coding186, + x64Parser::Coding187, + x64Parser::Coding188, + x64Parser::Coding189, + x64Parser::Coding190, + x64Parser::Coding191, + x64Parser::Coding192, + x64Parser::Coding193, + x64Parser::Coding194, + x64Parser::Coding195, + x64Parser::Coding196, + x64Parser::Coding197, + x64Parser::Coding198, + x64Parser::Coding199, + x64Parser::Coding200, + x64Parser::Coding201, + x64Parser::Coding202, + x64Parser::Coding203, + x64Parser::Coding204, + x64Parser::Coding205, + x64Parser::Coding206, + x64Parser::Coding207, + x64Parser::Coding208, + x64Parser::Coding209, + x64Parser::Coding210, + x64Parser::Coding211, + x64Parser::Coding212, + x64Parser::Coding213, + x64Parser::Coding214, + x64Parser::Coding215, + x64Parser::Coding216, + x64Parser::Coding217, + x64Parser::Coding218, + x64Parser::Coding219, + x64Parser::Coding220, + x64Parser::Coding221, + x64Parser::Coding222, + x64Parser::Coding223, + x64Parser::Coding224, + x64Parser::Coding225, + x64Parser::Coding226, + x64Parser::Coding227, + x64Parser::Coding228, + x64Parser::Coding229, + x64Parser::Coding230, + x64Parser::Coding231, + x64Parser::Coding232, + x64Parser::Coding233, + x64Parser::Coding234, + x64Parser::Coding235, + x64Parser::Coding236, + x64Parser::Coding237, + x64Parser::Coding238, + x64Parser::Coding239, + x64Parser::Coding240, + x64Parser::Coding241, + x64Parser::Coding242, + x64Parser::Coding243, + x64Parser::Coding244, + x64Parser::Coding245, + x64Parser::Coding246, + x64Parser::Coding247, + x64Parser::Coding248, + x64Parser::Coding249, + x64Parser::Coding250, + x64Parser::Coding251, + x64Parser::Coding252, + x64Parser::Coding253, + x64Parser::Coding254, + x64Parser::Coding255, + x64Parser::Coding256, + x64Parser::Coding257, + x64Parser::Coding258, + x64Parser::Coding259, + x64Parser::Coding260, + x64Parser::Coding261, + x64Parser::Coding262, + x64Parser::Coding263, + x64Parser::Coding264, + x64Parser::Coding265, + x64Parser::Coding266, + x64Parser::Coding267, + x64Parser::Coding268, + x64Parser::Coding269, + x64Parser::Coding270, + x64Parser::Coding271, + x64Parser::Coding272, + x64Parser::Coding273, + x64Parser::Coding274, + x64Parser::Coding275, + x64Parser::Coding276, + x64Parser::Coding277, + x64Parser::Coding278, + x64Parser::Coding279, + x64Parser::Coding280, + x64Parser::Coding281, + x64Parser::Coding282, + x64Parser::Coding283, + x64Parser::Coding284, + x64Parser::Coding285, + x64Parser::Coding286, + x64Parser::Coding287, + x64Parser::Coding288, + x64Parser::Coding289, + x64Parser::Coding290, + x64Parser::Coding291, + x64Parser::Coding292, + x64Parser::Coding293, + x64Parser::Coding294, + x64Parser::Coding295, + x64Parser::Coding296, + x64Parser::Coding297, + x64Parser::Coding298, + x64Parser::Coding299, + x64Parser::Coding300, + x64Parser::Coding301, + x64Parser::Coding302, + x64Parser::Coding303, + x64Parser::Coding304, + x64Parser::Coding305, + x64Parser::Coding306, + x64Parser::Coding307, + x64Parser::Coding308, + x64Parser::Coding309, + x64Parser::Coding310, + x64Parser::Coding311, + x64Parser::Coding312, + x64Parser::Coding313, + x64Parser::Coding314, + x64Parser::Coding315, + x64Parser::Coding316, + x64Parser::Coding317, + x64Parser::Coding318, + x64Parser::Coding319, + x64Parser::Coding320, + x64Parser::Coding321, + x64Parser::Coding322, + x64Parser::Coding323, + x64Parser::Coding324, + x64Parser::Coding325, + x64Parser::Coding326, + x64Parser::Coding327, + x64Parser::Coding328, + x64Parser::Coding329, + x64Parser::Coding330, + x64Parser::Coding331, + x64Parser::Coding332, + x64Parser::Coding333, + x64Parser::Coding334, + x64Parser::Coding335, + x64Parser::Coding336, + x64Parser::Coding337, + x64Parser::Coding338, + x64Parser::Coding339, + x64Parser::Coding340, + x64Parser::Coding341, + x64Parser::Coding342, + x64Parser::Coding343, + x64Parser::Coding344, + x64Parser::Coding345, + x64Parser::Coding346, + x64Parser::Coding347, + x64Parser::Coding348, + x64Parser::Coding349, + x64Parser::Coding350, + x64Parser::Coding351, + x64Parser::Coding352, + x64Parser::Coding353, + x64Parser::Coding354, + x64Parser::Coding355, + x64Parser::Coding356, + x64Parser::Coding357, + x64Parser::Coding358, + x64Parser::Coding359, + x64Parser::Coding360, + x64Parser::Coding361, + x64Parser::Coding362, + x64Parser::Coding363, + x64Parser::Coding364, + x64Parser::Coding365, + x64Parser::Coding366, + x64Parser::Coding367, + x64Parser::Coding368, + x64Parser::Coding369, + x64Parser::Coding370, + x64Parser::Coding371, + x64Parser::Coding372, + x64Parser::Coding373, + x64Parser::Coding374, + x64Parser::Coding375, + x64Parser::Coding376, + x64Parser::Coding377, + x64Parser::Coding378, + x64Parser::Coding379, + x64Parser::Coding380, + x64Parser::Coding381, + x64Parser::Coding382, + x64Parser::Coding383, + x64Parser::Coding384, + x64Parser::Coding385, + x64Parser::Coding386, + x64Parser::Coding387, + x64Parser::Coding388, + x64Parser::Coding389, + x64Parser::Coding390, + x64Parser::Coding391, + x64Parser::Coding392, + x64Parser::Coding393, + x64Parser::Coding394, + x64Parser::Coding395, + x64Parser::Coding396, + x64Parser::Coding397, + x64Parser::Coding398, + x64Parser::Coding399, + x64Parser::Coding400, + x64Parser::Coding401, + x64Parser::Coding402, + x64Parser::Coding403, + x64Parser::Coding404, + x64Parser::Coding405, + x64Parser::Coding406, + x64Parser::Coding407, + x64Parser::Coding408, + x64Parser::Coding409, + x64Parser::Coding410, + x64Parser::Coding411, + x64Parser::Coding412, + x64Parser::Coding413, + x64Parser::Coding414, + x64Parser::Coding415, + x64Parser::Coding416, + x64Parser::Coding417, + x64Parser::Coding418, + x64Parser::Coding419, + x64Parser::Coding420, + x64Parser::Coding421, + x64Parser::Coding422, + x64Parser::Coding423, + x64Parser::Coding424, + x64Parser::Coding425, + x64Parser::Coding426, + x64Parser::Coding427, + x64Parser::Coding428, + x64Parser::Coding429, + x64Parser::Coding430, + x64Parser::Coding431, + x64Parser::Coding432, + x64Parser::Coding433, + x64Parser::Coding434, + x64Parser::Coding435, + x64Parser::Coding436, + x64Parser::Coding437, + x64Parser::Coding438, + x64Parser::Coding439, + x64Parser::Coding440, + x64Parser::Coding441, + x64Parser::Coding442, + x64Parser::Coding443, + x64Parser::Coding444, + x64Parser::Coding445, + x64Parser::Coding446, + x64Parser::Coding447, + x64Parser::Coding448, + x64Parser::Coding449, + x64Parser::Coding450, + x64Parser::Coding451, + x64Parser::Coding452, + x64Parser::Coding453, + x64Parser::Coding454, + x64Parser::Coding455, + x64Parser::Coding456, + x64Parser::Coding457, + x64Parser::Coding458, + x64Parser::Coding459, + x64Parser::Coding460, + x64Parser::Coding461, + x64Parser::Coding462, + x64Parser::Coding463, + x64Parser::Coding464, + x64Parser::Coding465, + x64Parser::Coding466, + x64Parser::Coding467, + x64Parser::Coding468, + x64Parser::Coding469, + x64Parser::Coding470, + x64Parser::Coding471, + x64Parser::Coding472, + x64Parser::Coding473, + x64Parser::Coding474, + x64Parser::Coding475, + x64Parser::Coding476, + x64Parser::Coding477, + x64Parser::Coding478, + x64Parser::Coding479, + x64Parser::Coding480, + x64Parser::Coding481, + x64Parser::Coding482, + x64Parser::Coding483, + x64Parser::Coding484, + x64Parser::Coding485, + x64Parser::Coding486, + x64Parser::Coding487, + x64Parser::Coding488, + x64Parser::Coding489, + x64Parser::Coding490, + x64Parser::Coding491, + x64Parser::Coding492, + x64Parser::Coding493, + x64Parser::Coding494, + x64Parser::Coding495, + x64Parser::Coding496, + x64Parser::Coding497, + x64Parser::Coding498, + x64Parser::Coding499, + x64Parser::Coding500, + x64Parser::Coding501, + x64Parser::Coding502, + x64Parser::Coding503, + x64Parser::Coding504, + x64Parser::Coding505, + x64Parser::Coding506, + x64Parser::Coding507, + x64Parser::Coding508, + x64Parser::Coding509, + x64Parser::Coding510, + x64Parser::Coding511, + x64Parser::Coding512, + x64Parser::Coding513, + x64Parser::Coding514, + x64Parser::Coding515, + x64Parser::Coding516, + x64Parser::Coding517, + x64Parser::Coding518, + x64Parser::Coding519, + x64Parser::Coding520, + x64Parser::Coding521, + x64Parser::Coding522, + x64Parser::Coding523, + x64Parser::Coding524, + x64Parser::Coding525, + x64Parser::Coding526, + x64Parser::Coding527, + x64Parser::Coding528, + x64Parser::Coding529, + x64Parser::Coding530, + x64Parser::Coding531, + x64Parser::Coding532, + x64Parser::Coding533, + x64Parser::Coding534, + x64Parser::Coding535, + x64Parser::Coding536, + x64Parser::Coding537, + x64Parser::Coding538, + x64Parser::Coding539, + x64Parser::Coding540, + x64Parser::Coding541, + x64Parser::Coding542, + x64Parser::Coding543, + x64Parser::Coding544, + x64Parser::Coding545, + x64Parser::Coding546, + x64Parser::Coding547, + x64Parser::Coding548, + x64Parser::Coding549, + x64Parser::Coding550, + x64Parser::Coding551, + x64Parser::Coding552, + x64Parser::Coding553, + x64Parser::Coding554, + x64Parser::Coding555, + x64Parser::Coding556, + x64Parser::Coding557, + x64Parser::Coding558, + x64Parser::Coding559, + x64Parser::Coding560, + x64Parser::Coding561, + x64Parser::Coding562, + x64Parser::Coding563, + x64Parser::Coding564, + x64Parser::Coding565, + x64Parser::Coding566, + x64Parser::Coding567, + x64Parser::Coding568, + x64Parser::Coding569, + x64Parser::Coding570, + x64Parser::Coding571, + x64Parser::Coding572, + x64Parser::Coding573, + x64Parser::Coding574, + x64Parser::Coding575, + x64Parser::Coding576, + x64Parser::Coding577, + x64Parser::Coding578, + x64Parser::Coding579, + x64Parser::Coding580, + x64Parser::Coding581, + x64Parser::Coding582, + x64Parser::Coding583, + x64Parser::Coding584, + x64Parser::Coding585, + x64Parser::Coding586, + x64Parser::Coding587, + x64Parser::Coding588, + x64Parser::Coding589, + x64Parser::Coding590, + x64Parser::Coding591, + x64Parser::Coding592, + x64Parser::Coding593, + x64Parser::Coding594, + x64Parser::Coding595, + x64Parser::Coding596, + x64Parser::Coding597, + x64Parser::Coding598, + x64Parser::Coding599, + x64Parser::Coding600, + x64Parser::Coding601, + x64Parser::Coding602, + x64Parser::Coding603, + x64Parser::Coding604, + x64Parser::Coding605, + x64Parser::Coding606, + x64Parser::Coding607, + x64Parser::Coding608, + x64Parser::Coding609, + x64Parser::Coding610, + x64Parser::Coding611, + x64Parser::Coding612, + x64Parser::Coding613, + x64Parser::Coding614, + x64Parser::Coding615, + x64Parser::Coding616, + x64Parser::Coding617, + x64Parser::Coding618, + x64Parser::Coding619, + x64Parser::Coding620, + x64Parser::Coding621, + x64Parser::Coding622, + x64Parser::Coding623, + x64Parser::Coding624, + x64Parser::Coding625, + x64Parser::Coding626, + x64Parser::Coding627, + x64Parser::Coding628, + x64Parser::Coding629, + x64Parser::Coding630, + x64Parser::Coding631, + x64Parser::Coding632, + x64Parser::Coding633, + x64Parser::Coding634, + x64Parser::Coding635, + x64Parser::Coding636, + x64Parser::Coding637, + x64Parser::Coding638, + x64Parser::Coding639, + x64Parser::Coding640, + x64Parser::Coding641, + x64Parser::Coding642, + x64Parser::Coding643, + x64Parser::Coding644, + x64Parser::Coding645, + x64Parser::Coding646, + x64Parser::Coding647, + x64Parser::Coding648, + x64Parser::Coding649, + x64Parser::Coding650, + x64Parser::Coding651, + x64Parser::Coding652, + x64Parser::Coding653, + x64Parser::Coding654, + x64Parser::Coding655, + x64Parser::Coding656, + x64Parser::Coding657, + x64Parser::Coding658, + x64Parser::Coding659, + x64Parser::Coding660, + x64Parser::Coding661, + x64Parser::Coding662, + x64Parser::Coding663, + x64Parser::Coding664, + x64Parser::Coding665, + x64Parser::Coding666, + x64Parser::Coding667, + x64Parser::Coding668, + x64Parser::Coding669, + x64Parser::Coding670, + x64Parser::Coding671, + x64Parser::Coding672, + x64Parser::Coding673, + x64Parser::Coding674, + x64Parser::Coding675, + x64Parser::Coding676, + x64Parser::Coding677, + x64Parser::Coding678, + x64Parser::Coding679, + x64Parser::Coding680, + x64Parser::Coding681, + x64Parser::Coding682, + x64Parser::Coding683, + x64Parser::Coding684, + x64Parser::Coding685, + x64Parser::Coding686, + x64Parser::Coding687, + x64Parser::Coding688, + x64Parser::Coding689, + x64Parser::Coding690, + x64Parser::Coding691, + x64Parser::Coding692, + x64Parser::Coding693, + x64Parser::Coding694, + x64Parser::Coding695, + x64Parser::Coding696, + x64Parser::Coding697, + x64Parser::Coding698, + x64Parser::Coding699, + x64Parser::Coding700, + x64Parser::Coding701, + x64Parser::Coding702, + x64Parser::Coding703, + x64Parser::Coding704, + x64Parser::Coding705, + x64Parser::Coding706, + x64Parser::Coding707, + x64Parser::Coding708, + x64Parser::Coding709, + x64Parser::Coding710, + x64Parser::Coding711, + x64Parser::Coding712, + x64Parser::Coding713, + x64Parser::Coding714, + x64Parser::Coding715, + x64Parser::Coding716, + x64Parser::Coding717, + x64Parser::Coding718, + x64Parser::Coding719, + x64Parser::Coding720, + x64Parser::Coding721, + x64Parser::Coding722, + x64Parser::Coding723, + x64Parser::Coding724, + x64Parser::Coding725, + x64Parser::Coding726, + x64Parser::Coding727, + x64Parser::Coding728, + x64Parser::Coding729, + x64Parser::Coding730, + x64Parser::Coding731, + x64Parser::Coding732, }; Coding x64Parser::prefixCoding1[] = { - {CODING_NAME("a16") Coding::stateFunc, 1}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("a16") Coding::stateFunc, 1 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding2[] = { - {CODING_NAME("a32") Coding::stateFunc, 2}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("a32") Coding::stateFunc, 2 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding3[] = { - {CODING_NAME("lock")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("lock") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding4[] = { - {CODING_NAME("o16") Coding::stateFunc, 4}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("o16") Coding::stateFunc, 4 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding5[] = { - {CODING_NAME("o32") Coding::stateFunc, 5}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("o32") Coding::stateFunc, 5 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding6[] = { - {CODING_NAME("rep")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("rep") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding7[] = { - {CODING_NAME("repe")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding8[] = { - {CODING_NAME("repne")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding9[] = { - {CODING_NAME("repnz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, + { CODING_NAME("repnz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::prefixCoding10[] = { - {CODING_NAME("repz")(Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0}, - {CODING_NAME("eot") Coding::eot}, -}; -Coding* x64Parser::prefixCodings[] = { - x64Parser::prefixCoding1, x64Parser::prefixCoding2, x64Parser::prefixCoding3, x64Parser::prefixCoding4, - x64Parser::prefixCoding5, x64Parser::prefixCoding6, x64Parser::prefixCoding7, x64Parser::prefixCoding8, - x64Parser::prefixCoding9, x64Parser::prefixCoding10, + { CODING_NAME("repz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding *x64Parser::prefixCodings[] = { + x64Parser::prefixCoding1, + x64Parser::prefixCoding2, + x64Parser::prefixCoding3, + x64Parser::prefixCoding4, + x64Parser::prefixCoding5, + x64Parser::prefixCoding6, + x64Parser::prefixCoding7, + x64Parser::prefixCoding8, + x64Parser::prefixCoding9, + x64Parser::prefixCoding10, }; bool x64Parser::MatchesToken(int token, int tokenPos) { - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::TOKEN && - inputTokens[tokenPos]->val->ival == token; -} -bool x64Parser::MatchesRegister(int reg, int tokenPos) -{ - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && - inputTokens[tokenPos]->val->ival == reg; -} -bool x64Parser::MatchesRegisterClass(int cclass, int tokenPos) -{ - return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && - (registerDataIndirect[cclass][inputTokens[tokenPos]->val->ival >> 3] & (1 << (inputTokens[tokenPos]->val->ival & 7))); -} -bool x64Parser::ParseAddresses(x64Operand& operand, int addrClass, int& tokenPos) -{ - int level = 0; - bool rv = false; - x64Token* t = tokenBranches1; - while (t->type != x64Token::EOT) - { - bool matches = false; - if (t->addrClass[addrClass >> 3] & (1 << (addrClass & 7))) - { - switch (t->type) - { - case x64Token::EMPTY: - matches = true; - break; - case x64Token::TOKEN: - matches = MatchesToken(t->id, tokenPos); - break; - case x64Token::REGISTER: - matches = MatchesRegister(t->id, tokenPos); - break; - case x64Token::REGISTERCLASS: - matches = MatchesRegisterClass(t->id, tokenPos); - break; - case x64Token::NUMBER: - if (tokenPos < inputTokens.size()) - matches = (this->*numberFuncs[t->id])(tokenPos); - break; - default: - matches = false; - break; - } - } - if (!matches) - { - if (t->level > level) - { - t = t->next; - continue; - } - } - else - level = t->level; - if (matches) - { - if (t->tokenFunc) - (this->*(t->tokenFunc))(operand, tokenPos); - if (t->eos && (tokenPos == inputTokens.size() - 1 || !t->next)) - { - rv = true; - break; - } - t = t->next; - tokenPos++; - } - else - { - t++; - } - } - return rv; + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::TOKEN && inputTokens[tokenPos]->val->ival == token; +} + bool x64Parser::MatchesRegister(int reg, int tokenPos) +{ + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && inputTokens[tokenPos]->val->ival == reg; +} + bool x64Parser::MatchesRegisterClass(int cclass, int tokenPos) +{ + return tokenPos < inputTokens.size() && inputTokens[tokenPos]->type == InputToken::REGISTER && (registerDataIndirect[cclass][inputTokens[tokenPos]->val->ival >> 3] & (1 << (inputTokens[tokenPos]->val->ival & 7))); +} +bool x64Parser::ParseAddresses(x64Operand &operand, int addrClass, int &tokenPos) +{ + int level = 0; + bool rv = false; + x64Token *t = tokenBranches1; + while (t->type != x64Token::EOT) + { + bool matches = false; + if (t->addrClass[addrClass >> 3] & (1 << (addrClass & 7))) + { + switch (t->type) + { + case x64Token::EMPTY: + matches = true; + break; + case x64Token::TOKEN: + matches = MatchesToken(t->id, tokenPos); + break; + case x64Token::REGISTER: + matches = MatchesRegister(t->id, tokenPos); + break; + case x64Token::REGISTERCLASS: + matches = MatchesRegisterClass(t->id, tokenPos); + break; + case x64Token::NUMBER: + if (tokenPos < inputTokens.size()) + matches = (this->*numberFuncs[t->id])(tokenPos); + break; + default: + matches = false; + break; + } + } + if (!matches) + { + if (t->level > level) + { + t = t->next; + continue; + } + } + else + level = t->level; + if (matches) + { + if (t->tokenFunc) + (this->*(t->tokenFunc))(operand, tokenPos); + if (t->eos && (tokenPos == inputTokens.size()-1 || !t->next)) + { + rv = true; + break; + } + t = t->next; + tokenPos++; + } + else + { + t++; + } + } + return rv; } -asmError x64Parser::ParseOperands2(x64Token* tokenList, x64Operand& operand, int tokenPos, int level) -{ - asmError rv = AERR_OPERAND; - x64Token* t = tokenList; - while (t && t->type != x64Token::EOT) - { - bool matches = false; - int last = tokenPos; - switch (t->type) - { - case x64Token::EMPTY: - matches = true; - break; - case x64Token::TOKEN: - matches = MatchesToken(t->id, tokenPos); - break; - case x64Token::REGISTER: - matches = MatchesRegister(t->id, tokenPos); - break; - case x64Token::REGISTERCLASS: - matches = MatchesRegisterClass(t->id, tokenPos); - break; - case x64Token::ADDRESSCLASS: - matches = ParseAddresses(operand, t->id, tokenPos); - break; - case x64Token::NUMBER: - if (tokenPos < inputTokens.size()) - matches = (this->*numberFuncs[t->id])(tokenPos); - break; - default: - matches = false; - break; - } - if (!matches) - { - if (t->level > level) - { - rv = ParseOperands2(t->next, operand, tokenPos, t->level); - if (rv == AERR_NONE) - break; - } - } - else - { - if (t->tokenFunc) - (this->*(t->tokenFunc))(operand, last); - if (t->eos && (!t->next || tokenPos == inputTokens.size() - 1)) - { - bool ok = false; - if (operand.operandCoding != -1) - ok = CheckCoding(operand, Codings[operand.operandCoding]); - else if (operand.addressCoding != -1) - ok = CheckCoding(operand, Codings[operand.addressCoding]); - if (ok) - { - if (tokenPos >= (int)(inputTokens.size() - 1)) - eol = true; - rv = AERR_NONE; - break; - } - operand.operandCoding = -1; - operand.addressCoding = -1; - } - if (tokenPos < inputTokens.size()) - { - rv = ParseOperands2(t->next, operand, tokenPos + 1, t->level); - if (rv == AERR_NONE) - break; - } - } - tokenPos = last; - t++; - } - return rv; +asmError x64Parser::ParseOperands2(x64Token *tokenList, x64Operand &operand, int tokenPos, int level) +{ + asmError rv = AERR_OPERAND; + x64Token *t = tokenList; + while (t && t->type != x64Token::EOT) + { + bool matches = false; + int last = tokenPos; + switch (t->type) + { + case x64Token::EMPTY: + matches = true; + break; + case x64Token::TOKEN: + matches = MatchesToken(t->id, tokenPos); + break; + case x64Token::REGISTER: + matches = MatchesRegister(t->id, tokenPos); + break; + case x64Token::REGISTERCLASS: + matches = MatchesRegisterClass(t->id,tokenPos); + break; + case x64Token::ADDRESSCLASS: + matches = ParseAddresses(operand, t->id, tokenPos); + break; + case x64Token::NUMBER: + if (tokenPos < inputTokens.size()) + matches = (this->*numberFuncs[t->id])(tokenPos); + break; + default: + matches = false; + break; + } + if (!matches) + { + if (t->level > level) + { + rv = ParseOperands2(t->next, operand, tokenPos, t->level); + if (rv == AERR_NONE) + break; + } + } + else + { + if (t->tokenFunc) + (this->*(t->tokenFunc))(operand, last); + if (t->eos && (!t->next || tokenPos == inputTokens.size()-1)) + { + bool ok = false; + if (operand.operandCoding != -1) + ok = CheckCoding(operand, Codings[operand.operandCoding]); + else if (operand.addressCoding != -1) + ok = CheckCoding(operand, Codings[operand.addressCoding]); + if (ok) + { + if (tokenPos >= (int)(inputTokens.size()-1)) + eol = true; + rv = AERR_NONE; + break; + } + operand.operandCoding = -1; + operand.addressCoding = -1; + } + if (tokenPos < inputTokens.size()) + { + rv = ParseOperands2(t->next, operand, tokenPos + 1, t->level); + if (rv == AERR_NONE) + break; + } + } + tokenPos = last; + t++; + } + return rv; } -asmError x64Parser::ParseOperands(x64Token* tokenList, x64Operand& operand) -{ - asmError rv = ParseOperands2(tokenList, operand, 0, 0); - if (rv != AERR_NONE) - { - int n = tokenTable[","]; - std::vector fullList = inputTokens; - for (int i = 0; i < fullList.size();) - { - inputTokens.clear(); - while (i < fullList.size() && (fullList[i]->type != InputToken::TOKEN || fullList[i]->val->ival != n)) - inputTokens.push_back(fullList[i++]); - int j; - for (j = 0; j < sizeof(addressTable) / sizeof(addressTable[0]); j++) - { - if (ParseOperands2(addressTable[j], operand, 0, 0) == AERR_NONE) - break; - } - if (j == sizeof(addressTable) / sizeof(addressTable[0])) - { - inputTokens = fullList; - return AERR_OPERAND; - } - if (i < fullList.size()) - { - i++; - if (i == fullList.size()) - { - inputTokens = fullList; - return AERR_SYNTAX; - } - } - } - inputTokens = fullList; - return AERR_BADCOMBINATIONOFOPERANDS; - } - return rv; +asmError x64Parser::ParseOperands(x64Token *tokenList, x64Operand &operand) +{ + asmError rv = ParseOperands2(tokenList, operand, 0, 0); + if (rv != AERR_NONE) + { + int n = tokenTable[","]; + std::vectorfullList = inputTokens; + for (int i = 0; i < fullList.size();) + { + inputTokens.clear(); + while (i < fullList.size() && (fullList[i]->type != InputToken::TOKEN || fullList[i]->val->ival != n)) + inputTokens.push_back(fullList[i++]); + int j; + for (j = 0; j < sizeof(addressTable) / sizeof(addressTable[0]); j++) + { + if (ParseOperands2(addressTable[j], operand, 0, 0) == AERR_NONE) + break; + } + if (j == sizeof(addressTable) / sizeof(addressTable[0])) + { + inputTokens= fullList; + return AERR_OPERAND; + } + if (i < fullList.size()) + { + i++; + if (i == fullList.size()) + { + inputTokens= fullList; + return AERR_SYNTAX; + } + } + } + inputTokens= fullList; + return AERR_BADCOMBINATIONOFOPERANDS; + } + return rv; } -bool x64Parser::CheckCoding(x64Operand& operand, Coding* coding) -{ - while (coding->type != Coding::eot) - { - if (coding->type & Coding::stateFunc) - { - Coding* c = (this->*stateFuncs[coding->val])(); - if (!CheckCoding(operand, c)) - return false; - } - else if (coding->type & Coding::native) - { - if (operand.addressCoding == -1) - return false; - if (!CheckCoding(operand, Codings[operand.addressCoding])) - return false; - } - else if (coding->type & Coding::indirect) - { - if (!operand.values[coding->val]) - { - if (!(coding->type & Coding::optional)) - { - return false; - } - } - else - { - if (!CheckCoding(operand, operand.values[coding->val])) - return false; - } - } - else if (coding->type & Coding::illegal) - { - return false; - } - coding++; - } - return true; -} -bool x64Parser::ProcessCoding(x64Operand& operand, Coding* coding, int field, int bits, int* arr, char* bitcounts, char* func, - int& index) -{ - int acc = 0, binary = 0; - while (coding->type != Coding::eot) - { - if (coding->type & Coding::bitSpecified) - bits = coding->bits; - if (coding->type & Coding::valSpecified) - { - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = coding->val; - } - else if (coding->type & Coding::reg) - { - int n = coding->val; - if (field != -1) - n = registerValues[n][field]; - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = n; - } - else if (coding->type & Coding::stateFunc) - { - Coding* c = (this->*stateFuncs[coding->val])(); - int index1 = index; - if (!ProcessCoding(operand, c, coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - else if (coding->type & Coding::stateVar) - { - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = stateVars[coding->val]; - } - else if (coding->type & Coding::number) - { - int n = coding->val; - auto it = operands.begin(); - for (int i = 0; i < n; i++) - { - ++it; - } - (*it)->used = true; - n = 0; - for (int i = 0; i < index; i++) - if (!func[i]) - n += bitcounts[i]; - (*it)->pos = n; - func[index] = coding->binary; - bitcounts[index] = bits; - arr[index++] = (*it)->node->ival; - } - else if (coding->type & Coding::native) - { - if (operand.addressCoding == -1) - return false; - int index1 = index; - if (!ProcessCoding(operand, Codings[operand.addressCoding], coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - else if (coding->type & Coding::indirect) - { - if (!operand.values[coding->val]) - { - if (!(coding->type & Coding::optional)) - { - return false; - } - } - else - { - int index1 = index; - if (!ProcessCoding(operand, operand.values[coding->val], coding->field, bits, arr, bitcounts, func, index)) - return false; - if (index != index1 && coding->binary) - func[index - 1] = coding->binary; - } - } - else if (coding->type & Coding::illegal) - { - return false; - } - else - { - return false; - } - coding++; - } - return true; -} -bool x64Parser::ProcessCoding(x64Operand& operand, Coding* coding) -{ - int arr[1000]; - char bitcount[1000]; - char func[1000]; - int index = 0; - if (coding->type == Coding::eot) - return true; - int defaultBits = 8; - bool rv = ProcessCoding(operand, coding, -1, defaultBits, arr, bitcount, func, index); - if (rv) - { - for (int i = 0; i < index; i++) - { - if (func[i]) - arr[i + 1] = DoMath(func[i], arr[i], arr[i + 1]); - else - bits.Add(arr[i], bitcount[i]); - } - } - return rv; +bool x64Parser::CheckCoding(x64Operand &operand,Coding *coding) +{ + while (coding->type != Coding::eot) + { + if (coding->type & Coding::stateFunc) + { + Coding *c = (this->*stateFuncs[coding->val])(); + if (!CheckCoding(operand, c)) + return false; + } + else if (coding->type & Coding::native) + { + if (operand.addressCoding == -1) + return false; + if (!CheckCoding(operand, Codings[operand.addressCoding])) + return false; + } + else if (coding->type & Coding::indirect) + { + if (!operand.values[coding->val]) + { + if (!(coding->type & Coding::optional)) + { + return false; + } + } + else + { + if (!CheckCoding(operand, operand.values[coding->val])) + return false; + } + } + else if (coding->type & Coding::illegal) + { + return false; + } + coding++; + } + return true; +} +bool x64Parser::ProcessCoding(x64Operand &operand, Coding *coding, int field, int bits, int* arr, char* bitcounts, char *func, int &index) +{ + int acc = 0, binary = 0; + while (coding->type != Coding::eot) + { + if (coding->type & Coding::bitSpecified) + bits = coding->bits; + if (coding->type & Coding::valSpecified) + { + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = coding->val; + } + else if (coding->type & Coding::reg) + { + int n = coding->val; + if (field != -1) + n = registerValues[n][field]; + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = n; + } + else if (coding->type & Coding::stateFunc) + { + Coding *c = (this->*stateFuncs[coding->val])(); + int index1 = index; + if (!ProcessCoding(operand, c, coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + else if (coding->type & Coding::stateVar) + { + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = stateVars[coding->val]; + } + else if (coding->type & Coding::number) + { + int n = coding->val; + auto it = operands.begin(); + for (int i = 0; i < n; i++) + { + ++it; + } + (*it)->used = true; + n = 0; + for (int i = 0; i < index; i++) + if (!func[i]) + n += bitcounts[i]; + (*it)->pos = n; + func[index] = coding->binary; + bitcounts[index] = bits; + arr[index++] = (*it)->node->ival; + } + else if (coding->type & Coding::native) + { + if (operand.addressCoding == -1) + return false; + int index1 = index; + if (!ProcessCoding(operand, Codings[operand.addressCoding], coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + else if (coding->type & Coding::indirect) + { + if (!operand.values[coding->val]) + { + if (!(coding->type & Coding::optional)) + { + return false; + } + } + else + { + int index1 = index; + if (!ProcessCoding(operand, operand.values[coding->val], coding->field, bits, arr, bitcounts, func, index)) + return false; + if (index != index1 && coding->binary) + func[index - 1] = coding->binary; + } + } + else if (coding->type & Coding::illegal) + { + return false; + } + else + { + return false; + } + coding++; + } + return true; +} +bool x64Parser::ProcessCoding(x64Operand &operand, Coding *coding) +{ + int arr[1000]; + char bitcount[1000]; + char func[1000]; + int index = 0; + if (coding->type == Coding::eot) + return true; + int defaultBits = 8; + bool rv = ProcessCoding(operand, coding, -1, defaultBits, arr, bitcount, func, index); + if (rv) + { + for (int i = 0; i < index; i++) + { + if (func[i]) + arr[i + 1] = DoMath(func[i], arr[i], arr[i + 1]); + else + bits.Add(arr[i], bitcount[i]); + } + } + return rv; } asmError x64Parser::DispatchOpcode(int opcode) { - bool rv = true; - if (opcode == -1) - { - x64Operand operand; - for (auto& a : prefixes) - rv &= ProcessCoding(operand, prefixCodings[a]); - if (!rv) - return AERR_UNKNOWNOPCODE; - } - else - { - x64Operand operand; - operand.opcode = opcode; - auto err = (this->*DispatchTable[opcode])(operand); - if (err == AERR_NONE) - { - for (auto& a : prefixes) - rv &= ProcessCoding(operand, prefixCodings[a]); - if (rv) - { - if (operand.operandCoding != -1) - rv = ProcessCoding(operand, Codings[operand.operandCoding]); - else if (operand.addressCoding != -1) - rv = ProcessCoding(operand, Codings[operand.addressCoding]); - else - rv = false; - if (!rv) - return AERR_INVALIDINSTRUCTIONUSE; - } - } - else - { - return err; - } - } - return AERR_NONE; + bool rv=true; + if (opcode == -1) + { + x64Operand operand; + for (auto& a : prefixes) + rv &= ProcessCoding(operand, prefixCodings[a]); + if (!rv) + return AERR_UNKNOWNOPCODE; + } + else + { + x64Operand operand; + operand.opcode = opcode; + auto err = (this->*DispatchTable[opcode])(operand); + if (err == AERR_NONE) + { + for (auto& a : prefixes) + rv &= ProcessCoding(operand, prefixCodings[a]); + if (rv) + { + if (operand.operandCoding != -1) + rv = ProcessCoding(operand, Codings[operand.operandCoding]); + else if (operand.addressCoding != -1) + rv = ProcessCoding(operand, Codings[operand.addressCoding]); + else rv = false; + if (!rv) + return AERR_INVALIDINSTRUCTIONUSE; + } + } + else + { + return err; + } + } + return AERR_NONE; } From bbbf68b610c3cbb9f91a39e6b529240c0bad403b Mon Sep 17 00:00:00 2001 From: chuggafan Date: Wed, 4 Feb 2026 22:36:06 -0500 Subject: [PATCH 8/9] Reduce strlen instruction size by one --- src/clibs/string/386/strlen.nas | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-) diff --git a/src/clibs/string/386/strlen.nas b/src/clibs/string/386/strlen.nas index 082693963..236b46127 100644 --- a/src/clibs/string/386/strlen.nas +++ b/src/clibs/string/386/strlen.nas @@ -12,43 +12,41 @@ %define nop8 db 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00000000H] %define nop9 db 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H] %ifdef __BUILDING_LSCRTL_DLL -[export _strlen] +[export _strlen2] %endif -[global _strlen] +[global _strlen2] SECTION code CLASS=CODE USE32 -_strlen: - mov eax, [esp+4] - xor edx, edx - test al, 15 +_strlen2: + mov edx, [esp+4] + xor eax, eax + test dl, 15 je SHORT hot_loop_prep nop6 alignment_loop: - mov cl, [eax] - inc eax + mov cl, [edx] + inc edx test cl, cl je easy_exit - inc edx + inc eax test al, 15 jne alignment_loop hot_loop_prep: - movaps xmm0, [eax] + movaps xmm0, [edx] xorps xmm1, xmm1 pcmpeqb xmm0, xmm1 pmovmskb ecx, xmm0 test ecx, ecx jne sse_exit - sub eax, edx + sub edx, eax hot_loop: movaps xmm0, [eax+edx+16] - add edx, 16 + add eax, 16 pcmpeqb xmm0, xmm1 pmovmskb ecx, xmm0 test ecx, ecx je SHORT hot_loop sse_exit: - bsf eax, ecx + bsf edx, ecx add eax, edx - ret easy_exit: - mov eax, edx ret From 6964104821834ad2758eb909904eba5dadecab74 Mon Sep 17 00:00:00 2001 From: chuggafan Date: Sun, 8 Mar 2026 21:21:56 -0400 Subject: [PATCH 9/9] Update to add clflush and clfushopt Also fix my strlen modification to subtract a single instruction. Also decorate with noreturn noreturn functions. --- src/adl/GenParser.cpp | 2 +- src/clibs/stdinc/_defs.h | 6 +- src/clibs/stdinc/libp.h | 2 +- src/clibs/string/386/strlen.nas | 8 +- src/oasm/x64.adl | 8 +- src/oasm/x64Instructions.cpp | 4 +- src/oasm/x64Instructions.h | 1072 +-- src/oasm/x64Parser.cpp | 15290 +++++++++++++++--------------- src/oasm/x64Parser.h | 3513 +++---- src/occ/x64Parser.cpp | 15290 +++++++++++++++--------------- 10 files changed, 17698 insertions(+), 17497 deletions(-) diff --git a/src/adl/GenParser.cpp b/src/adl/GenParser.cpp index 178f02f10..a5735e42c 100644 --- a/src/adl/GenParser.cpp +++ b/src/adl/GenParser.cpp @@ -1203,7 +1203,7 @@ bool GenParser::GenerateOpcodes() } else { - std::cout << "Undefined opcode class '" << x->cclass << "' in definition of opcode '" << x->name << "'"; + std::cout << "Undefined opcode class '" << x->cclass << "' in definition of opcode '" << x->name << "'" << std::endl; } } else diff --git a/src/clibs/stdinc/_defs.h b/src/clibs/stdinc/_defs.h index cde9388c4..a24c53185 100644 --- a/src/clibs/stdinc/_defs.h +++ b/src/clibs/stdinc/_defs.h @@ -88,10 +88,12 @@ # define __STD_NS_QUALIFIER # endif -# if __STDC_VERSION__ < 201112L || defined(__cplusplus) +# if __STDC_VERSION__ < 201112L && !defined(__cplusplus) # define _NORETURN -# else +# elif __STDC_VERSION__ < 202311L && !defined(__cplusplus) # define _NORETURN _Noreturn +#else +# define _NORETURN [[noreturn]] # endif /* the headers use the restrict keyword, which is not valid prior to diff --git a/src/clibs/stdinc/libp.h b/src/clibs/stdinc/libp.h index 1d3d2463a..b77b57fc5 100644 --- a/src/clibs/stdinc/libp.h +++ b/src/clibs/stdinc/libp.h @@ -120,7 +120,7 @@ extern "C" { # endif int __ll_thrdstart(struct ithrd** thr, thrd_start_t* func, void* arglist); - void __ll_thrdexit(unsigned retval); + _NORETURN void __ll_thrdexit(unsigned retval); void __ll_thrdsleep(unsigned ms); void _RTL_FUNC _IMPORT __thrdRegisterModule(void* module, void* tlsStart, void* tlsEnd); void _RTL_FUNC _IMPORT __thrdUnregisterModule(void* module); diff --git a/src/clibs/string/386/strlen.nas b/src/clibs/string/386/strlen.nas index 236b46127..d2cf577a9 100644 --- a/src/clibs/string/386/strlen.nas +++ b/src/clibs/string/386/strlen.nas @@ -12,11 +12,11 @@ %define nop8 db 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; NOP DWORD ptr [EAX + EAX*1 + 00000000H] %define nop9 db 0x66, 0x0F, 0x1F, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00 ; 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H] %ifdef __BUILDING_LSCRTL_DLL -[export _strlen2] +[export _strlen] %endif -[global _strlen2] +[global _strlen] SECTION code CLASS=CODE USE32 -_strlen2: +_strlen: mov edx, [esp+4] xor eax, eax test dl, 15 @@ -28,7 +28,7 @@ alignment_loop: test cl, cl je easy_exit inc eax - test al, 15 + test edx, 15 jne alignment_loop hot_loop_prep: movaps xmm0, [edx] diff --git a/src/oasm/x64.adl b/src/oasm/x64.adl index 97d0c7d25..bab333a84 100644 --- a/src/oasm/x64.adl +++ b/src/oasm/x64.adl @@ -1319,7 +1319,7 @@ - " + @@ -1465,6 +1465,12 @@ + + + + + + diff --git a/src/oasm/x64Instructions.cpp b/src/oasm/x64Instructions.cpp index 8e4fbd924..15c61eaa4 100644 --- a/src/oasm/x64Instructions.cpp +++ b/src/oasm/x64Instructions.cpp @@ -2,7 +2,7 @@ #include "x64Instructions.h" -const char * const opcodeTable[631] = { +const char * const opcodeTable[633] = { "", "", "", @@ -100,6 +100,8 @@ const char * const opcodeTable[631] = { "cmpxchg8b", "cmpxchg16b", "cpuid", + "clflush", + "clflushopt", "cqo", "cwd", "cwde", diff --git a/src/oasm/x64Instructions.h b/src/oasm/x64Instructions.h index 3b26a5c32..4c272caf2 100644 --- a/src/oasm/x64Instructions.h +++ b/src/oasm/x64Instructions.h @@ -70,540 +70,542 @@ enum e_opcode { op_cmpxchg8b = 94, op_cmpxchg16b = 95, op_cpuid = 96, - op_cqo = 97, - op_cwd = 98, - op_cwde = 99, - op_daa = 100, - op_das = 101, - op_dec = 102, - op_div = 103, - op_enter = 104, - op_esc = 105, - op_f2xm1 = 106, - op_fabs = 107, - op_fadd = 108, - op_faddp = 109, - op_fbld = 110, - op_fbstp = 111, - op_fchs = 112, - op_fclex = 113, - op_fnclex = 114, - op_fcmovb = 115, - op_fcmovbe = 116, - op_fcmove = 117, - op_fcmovnb = 118, - op_fcmovnbe = 119, - op_fcmovne = 120, - op_fcmovnu = 121, - op_fcmovu = 122, - op_fcom = 123, - op_fcomi = 124, - op_fcomip = 125, - op_fcomp = 126, - op_fcompp = 127, - op_fcos = 128, - op_fdecstp = 129, - op_fdisi = 130, - op_fdiv = 131, - op_fdivp = 132, - op_fdivr = 133, - op_fdivrp = 134, - op_feni = 135, - op_ffree = 136, - op_ffreep = 137, - op_fiadd = 138, - op_ficom = 139, - op_ficomp = 140, - op_fidiv = 141, - op_fidivr = 142, - op_fild = 143, - op_fimul = 144, - op_fincstp = 145, - op_finit = 146, - op_fninit = 147, - op_fist = 148, - op_fistp = 149, - op_fisub = 150, - op_fisubr = 151, - op_fld = 152, - op_fld1 = 153, - op_fldcw = 154, - op_fldenv = 155, - op_fldl2e = 156, - op_fldl2t = 157, - op_fldlg2 = 158, - op_fldln2 = 159, - op_fldpi = 160, - op_fldz = 161, - op_fmul = 162, - op_fmulp = 163, - op_fnop = 164, - op_fnsave = 165, - op_fpatan = 166, - op_fprem = 167, - op_fprem1 = 168, - op_fptan = 169, - op_frndint = 170, - op_frstor = 171, - op_fsave = 172, - op_fscale = 173, - op_fsetpm = 174, - op_fsin = 175, - op_fsincos = 176, - op_fsqrt = 177, - op_fst = 178, - op_fstcw = 179, - op_fnstcw = 180, - op_fstenv = 181, - op_fnstenv = 182, - op_fstp = 183, - op_fstsw = 184, - op_fnstsw = 185, - op_fsub = 186, - op_fsubp = 187, - op_fsubr = 188, - op_fsubrp = 189, - op_ftst = 190, - op_fucom = 191, - op_fucomi = 192, - op_fucomip = 193, - op_fucomp = 194, - op_fucompp = 195, - op_fwait = 196, - op_fxam = 197, - op_fxch = 198, - op_fxch4 = 199, - op_fxch7 = 200, - op_fxrstor = 201, - op_fxsave = 202, - op_fxtract = 203, - op_fyl2x = 204, - op_fyl2xp1 = 205, - op_hlt = 206, - op_icebp = 207, - op_idiv = 208, - op_imul = 209, - op_in = 210, - op_ins = 211, - op_insb = 212, - op_insw = 213, - op_insd = 214, - op_inc = 215, - op_int = 216, - op_int1 = 217, - op_int3 = 218, - op_into = 219, - op_invd = 220, - op_invlpg = 221, - op_iret = 222, - op_iretw = 223, - op_iretd = 224, - op_iretq = 225, - op_ja = 226, - op_jae = 227, - op_jb = 228, - op_jbe = 229, - op_jc = 230, - op_jcxz = 231, - op_jecxz = 232, - op_je = 233, - op_jg = 234, - op_jge = 235, - op_jl = 236, - op_jle = 237, - op_jmp = 238, - op_jna = 239, - op_jnae = 240, - op_jnb = 241, - op_jnbe = 242, - op_jnc = 243, - op_jne = 244, - op_jng = 245, - op_jnge = 246, - op_jnl = 247, - op_jnle = 248, - op_jno = 249, - op_jnp = 250, - op_jns = 251, - op_jnz = 252, - op_jo = 253, - op_jp = 254, - op_jpe = 255, - op_jpo = 256, - op_js = 257, - op_jz = 258, - op_lahf = 259, - op_lar = 260, - op_lds = 261, - op_lea = 262, - op_leave = 263, - op_les = 264, - op_lfence = 265, - op_lfs = 266, - op_lgdt = 267, - op_lgs = 268, - op_lidt = 269, - op_lldt = 270, - op_lmsw = 271, - op_lods = 272, - op_lodsb = 273, - op_lodsw = 274, - op_lodsd = 275, - op_lodsq = 276, - op_loop = 277, - op_loope = 278, - op_loopne = 279, - op_loopnz = 280, - op_loopz = 281, - op_lsl = 282, - op_lss = 283, - op_ltr = 284, - op_mov = 285, - op_movs = 286, - op_movbe = 287, - op_movsb = 288, - op_movsw = 289, - op_movsd = 290, - op_movsq = 291, - op_movsx = 292, - op_movzx = 293, - op_movsxd = 294, - op_mul = 295, - op_neg = 296, - op_nop = 297, - op_not = 298, - op_or = 299, - op_out = 300, - op_outs = 301, - op_outsb = 302, - op_outsw = 303, - op_outsd = 304, - op_pop = 305, - op_popa = 306, - op_popaw = 307, - op_popad = 308, - op_popcnt = 309, - op_popf = 310, - op_popfw = 311, - op_popfd = 312, - op_popfq = 313, - op_prefetchnta = 314, - op_prefetcht0 = 315, - op_prefetcht1 = 316, - op_prefetcht2 = 317, - op_push = 318, - op_pusha = 319, - op_pushaw = 320, - op_pushad = 321, - op_pushf = 322, - op_pushfw = 323, - op_pushfd = 324, - op_pushfq = 325, - op_rcl = 326, - op_rcr = 327, - op_rdmsr = 328, - op_rdpmc = 329, - op_rdtsc = 330, - op_ret = 331, - op_retf = 332, - op_rol = 333, - op_ror = 334, - op_rsm = 335, - op_sahf = 336, - op_sal = 337, - op_sar = 338, - op_sbb = 339, - op_scas = 340, - op_scasb = 341, - op_scasw = 342, - op_scasd = 343, - op_scasq = 344, - op_seta = 345, - op_setae = 346, - op_setb = 347, - op_setbe = 348, - op_setc = 349, - op_sete = 350, - op_setg = 351, - op_setge = 352, - op_setl = 353, - op_setle = 354, - op_setna = 355, - op_setnae = 356, - op_setnb = 357, - op_setnbe = 358, - op_setnc = 359, - op_setne = 360, - op_setng = 361, - op_setnge = 362, - op_setnl = 363, - op_setnle = 364, - op_setno = 365, - op_setnp = 366, - op_setns = 367, - op_setnz = 368, - op_seto = 369, - op_setp = 370, - op_setpe = 371, - op_setpo = 372, - op_sets = 373, - op_setz = 374, - op_sfence = 375, - op_sgdt = 376, - op_shl = 377, - op_shld = 378, - op_shr = 379, - op_shrd = 380, - op_sidt = 381, - op_sldt = 382, - op_smsw = 383, - op_stc = 384, - op_std = 385, - op_sti = 386, - op_stos = 387, - op_stosb = 388, - op_stosw = 389, - op_stosd = 390, - op_stosq = 391, - op_str = 392, - op_sub = 393, - op_syscall = 394, - op_sysenter = 395, - op_sysexit = 396, - op_sysret = 397, - op_test = 398, - op_ud2 = 399, - op_verr = 400, - op_verw = 401, - op_wait = 402, - op_wbinvd = 403, - op_wrmsr = 404, - op_xadd = 405, - op_xchg = 406, - op_xlat = 407, - op_xlatb = 408, - op_xor = 409, - op_xrstor = 410, - op_xrstor64 = 411, - op_xsave = 412, - op_xsave64 = 413, - op_xsetbv = 414, - op_addpd = 415, - op_addps = 416, - op_addsd = 417, - op_addss = 418, - op_addsubpd = 419, - op_addsubps = 420, - op_andnpd = 421, - op_andnps = 422, - op_andpd = 423, - op_andps = 424, - op_blendpd = 425, - op_blendps = 426, - op_cmppd = 427, - op_cmpps = 428, - op_comisd = 429, - op_comiss = 430, - op_cvtdq2pd = 431, - op_cvtdq2ps = 432, - op_cvtpd2dq = 433, - op_cvtpd2pi = 434, - op_cvtpd2ps = 435, - op_cvtpi2pd = 436, - op_cvtpi2ps = 437, - op_cvtps2dq = 438, - op_cvtps2pd = 439, - op_cvtps2pi = 440, - op_cvtsd2si = 441, - op_cvtsd2ss = 442, - op_cvtsi2sd = 443, - op_cvtsi2ss = 444, - op_cvtss2sd = 445, - op_cvtss2si = 446, - op_cvttpd2dq = 447, - op_cvttpd2pi = 448, - op_cvttps2dq = 449, - op_cvttps2pi = 450, - op_cvttsd2si = 451, - op_cvttss2si = 452, - op_divpd = 453, - op_divps = 454, - op_divsd = 455, - op_divss = 456, - op_dppd = 457, - op_dpps = 458, - op_hsubpd = 459, - op_hsubps = 460, - op_insertps = 461, - op_lddqu = 462, - op_maskmovdqu = 463, - op_maskmovq = 464, - op_maxpd = 465, - op_maxps = 466, - op_maxsd = 467, - op_maxss = 468, - op_mfence = 469, - op_pause = 470, - op_minpd = 471, - op_minps = 472, - op_minsd = 473, - op_minss = 474, - op_monitor = 475, - op_movapd = 476, - op_movaps = 477, - op_movd = 478, - op_movq = 479, - op_movddup = 480, - op_movdq2q = 481, - op_movdqa = 482, - op_movdqu = 483, - op_movhlps = 484, - op_movhpd = 485, - op_movhps = 486, - op_movlhps = 487, - op_movlpd = 488, - op_movlps = 489, - op_movmskpd = 490, - op_movmskps = 491, - op_movntdq = 492, - op_movnti = 493, - op_movntpd = 494, - op_movntd = 495, - op_movntq = 496, - op_movq2dq = 497, - op_movshdup = 498, - op_movsldup = 499, - op_movss = 500, - op_movupd = 501, - op_movups = 502, - op_mpsadbw = 503, - op_mulpd = 504, - op_mulps = 505, - op_mulsd = 506, - op_mulss = 507, - op_orpd = 508, - op_orps = 509, - op_packssdw = 510, - op_packsswb = 511, - op_packusdw = 512, - op_paddb = 513, - op_paddd = 514, - op_paddq = 515, - op_paddsw = 516, - op_paddusb = 517, - op_paddusw = 518, - op_paddw = 519, - op_palignr = 520, - op_pand = 521, - op_pandn = 522, - op_pavgb = 523, - op_pavgw = 524, - op_pblendw = 525, - op_pcmpeqb = 526, - op_pcmpeqd = 527, - op_pcmpeqw = 528, - op_pcmpestri = 529, - op_pcmpestrm = 530, - op_pcmpgtb = 531, - op_pcmpgtd = 532, - op_pcmpgtw = 533, - op_pextrb = 534, - op_pextrd = 535, - op_pextrq = 536, - op_pextrw = 537, - op_pinsrb = 538, - op_pinsrd = 539, - op_pinsrq = 540, - op_pinsrw = 541, - op_pmaddwd = 542, - op_pmaxsw = 543, - op_pmaxub = 544, - op_pminsw = 545, - op_pminub = 546, - op_pmovmskb = 547, - op_pmulhuw = 548, - op_pmulhw = 549, - op_pmullw = 550, - op_pmuludq = 551, - op_psadbw = 552, - op_pshufd = 553, - op_pshufhw = 554, - op_pshuflw = 555, - op_pshufw = 556, - op_pslld = 557, - op_pslldq = 558, - op_psllq = 559, - op_psllw = 560, - op_psrad = 561, - op_psraw = 562, - op_psrld = 563, - op_psrldq = 564, - op_psrlq = 565, - op_psrlw = 566, - op_psubb = 567, - op_psubd = 568, - op_psubq = 569, - op_psubsb = 570, - op_psubsw = 571, - op_psubusb = 572, - op_psubusw = 573, - op_punpckhbw = 574, - op_punpckhdq = 575, - op_punpckhqdq = 576, - op_punpckhwd = 577, - op_punpcklbw = 578, - op_punpckldq = 579, - op_punpcklqdq = 580, - op_punpcklwd = 581, - op_pxor = 582, - op_rcpps = 583, - op_rcpss = 584, - op_roundpd = 585, - op_roundps = 586, - op_roundsd = 587, - op_roundss = 588, - op_rsqrtps = 589, - op_rsqrtss = 590, - op_shufpd = 591, - op_shufps = 592, - op_sqrtpd = 593, - op_sqrtps = 594, - op_sqrtsd = 595, - op_sqrtss = 596, - op_subpd = 597, - op_subps = 598, - op_subsd = 599, - op_subss = 600, - op_ucomisd = 601, - op_ucomiss = 602, - op_unpckhpd = 603, - op_unpckhps = 604, - op_unpcklpd = 605, - op_unpcklps = 606, - op_xorpd = 607, - op_xorps = 608, - op_invept = 609, - op_invvpid = 610, - op_vmcall = 611, - op_vmclear = 612, - op_vmlaunch = 613, - op_vmptrld = 614, - op_vmptrst = 615, - op_vmread = 616, - op_vmresume = 617, - op_vmwrite = 618, - op_vmxoff = 619, - op_vmxon = 620, - op_a16 = 621, - op_a32 = 622, - op_lock = 623, - op_o16 = 624, - op_o32 = 625, - op_rep = 626, - op_repe = 627, - op_repne = 628, - op_repnz = 629, - op_repz = 630, + op_clflush = 97, + op_clflushopt = 98, + op_cqo = 99, + op_cwd = 100, + op_cwde = 101, + op_daa = 102, + op_das = 103, + op_dec = 104, + op_div = 105, + op_enter = 106, + op_esc = 107, + op_f2xm1 = 108, + op_fabs = 109, + op_fadd = 110, + op_faddp = 111, + op_fbld = 112, + op_fbstp = 113, + op_fchs = 114, + op_fclex = 115, + op_fnclex = 116, + op_fcmovb = 117, + op_fcmovbe = 118, + op_fcmove = 119, + op_fcmovnb = 120, + op_fcmovnbe = 121, + op_fcmovne = 122, + op_fcmovnu = 123, + op_fcmovu = 124, + op_fcom = 125, + op_fcomi = 126, + op_fcomip = 127, + op_fcomp = 128, + op_fcompp = 129, + op_fcos = 130, + op_fdecstp = 131, + op_fdisi = 132, + op_fdiv = 133, + op_fdivp = 134, + op_fdivr = 135, + op_fdivrp = 136, + op_feni = 137, + op_ffree = 138, + op_ffreep = 139, + op_fiadd = 140, + op_ficom = 141, + op_ficomp = 142, + op_fidiv = 143, + op_fidivr = 144, + op_fild = 145, + op_fimul = 146, + op_fincstp = 147, + op_finit = 148, + op_fninit = 149, + op_fist = 150, + op_fistp = 151, + op_fisub = 152, + op_fisubr = 153, + op_fld = 154, + op_fld1 = 155, + op_fldcw = 156, + op_fldenv = 157, + op_fldl2e = 158, + op_fldl2t = 159, + op_fldlg2 = 160, + op_fldln2 = 161, + op_fldpi = 162, + op_fldz = 163, + op_fmul = 164, + op_fmulp = 165, + op_fnop = 166, + op_fnsave = 167, + op_fpatan = 168, + op_fprem = 169, + op_fprem1 = 170, + op_fptan = 171, + op_frndint = 172, + op_frstor = 173, + op_fsave = 174, + op_fscale = 175, + op_fsetpm = 176, + op_fsin = 177, + op_fsincos = 178, + op_fsqrt = 179, + op_fst = 180, + op_fstcw = 181, + op_fnstcw = 182, + op_fstenv = 183, + op_fnstenv = 184, + op_fstp = 185, + op_fstsw = 186, + op_fnstsw = 187, + op_fsub = 188, + op_fsubp = 189, + op_fsubr = 190, + op_fsubrp = 191, + op_ftst = 192, + op_fucom = 193, + op_fucomi = 194, + op_fucomip = 195, + op_fucomp = 196, + op_fucompp = 197, + op_fwait = 198, + op_fxam = 199, + op_fxch = 200, + op_fxch4 = 201, + op_fxch7 = 202, + op_fxrstor = 203, + op_fxsave = 204, + op_fxtract = 205, + op_fyl2x = 206, + op_fyl2xp1 = 207, + op_hlt = 208, + op_icebp = 209, + op_idiv = 210, + op_imul = 211, + op_in = 212, + op_ins = 213, + op_insb = 214, + op_insw = 215, + op_insd = 216, + op_inc = 217, + op_int = 218, + op_int1 = 219, + op_int3 = 220, + op_into = 221, + op_invd = 222, + op_invlpg = 223, + op_iret = 224, + op_iretw = 225, + op_iretd = 226, + op_iretq = 227, + op_ja = 228, + op_jae = 229, + op_jb = 230, + op_jbe = 231, + op_jc = 232, + op_jcxz = 233, + op_jecxz = 234, + op_je = 235, + op_jg = 236, + op_jge = 237, + op_jl = 238, + op_jle = 239, + op_jmp = 240, + op_jna = 241, + op_jnae = 242, + op_jnb = 243, + op_jnbe = 244, + op_jnc = 245, + op_jne = 246, + op_jng = 247, + op_jnge = 248, + op_jnl = 249, + op_jnle = 250, + op_jno = 251, + op_jnp = 252, + op_jns = 253, + op_jnz = 254, + op_jo = 255, + op_jp = 256, + op_jpe = 257, + op_jpo = 258, + op_js = 259, + op_jz = 260, + op_lahf = 261, + op_lar = 262, + op_lds = 263, + op_lea = 264, + op_leave = 265, + op_les = 266, + op_lfence = 267, + op_lfs = 268, + op_lgdt = 269, + op_lgs = 270, + op_lidt = 271, + op_lldt = 272, + op_lmsw = 273, + op_lods = 274, + op_lodsb = 275, + op_lodsw = 276, + op_lodsd = 277, + op_lodsq = 278, + op_loop = 279, + op_loope = 280, + op_loopne = 281, + op_loopnz = 282, + op_loopz = 283, + op_lsl = 284, + op_lss = 285, + op_ltr = 286, + op_mov = 287, + op_movs = 288, + op_movbe = 289, + op_movsb = 290, + op_movsw = 291, + op_movsd = 292, + op_movsq = 293, + op_movsx = 294, + op_movzx = 295, + op_movsxd = 296, + op_mul = 297, + op_neg = 298, + op_nop = 299, + op_not = 300, + op_or = 301, + op_out = 302, + op_outs = 303, + op_outsb = 304, + op_outsw = 305, + op_outsd = 306, + op_pop = 307, + op_popa = 308, + op_popaw = 309, + op_popad = 310, + op_popcnt = 311, + op_popf = 312, + op_popfw = 313, + op_popfd = 314, + op_popfq = 315, + op_prefetchnta = 316, + op_prefetcht0 = 317, + op_prefetcht1 = 318, + op_prefetcht2 = 319, + op_push = 320, + op_pusha = 321, + op_pushaw = 322, + op_pushad = 323, + op_pushf = 324, + op_pushfw = 325, + op_pushfd = 326, + op_pushfq = 327, + op_rcl = 328, + op_rcr = 329, + op_rdmsr = 330, + op_rdpmc = 331, + op_rdtsc = 332, + op_ret = 333, + op_retf = 334, + op_rol = 335, + op_ror = 336, + op_rsm = 337, + op_sahf = 338, + op_sal = 339, + op_sar = 340, + op_sbb = 341, + op_scas = 342, + op_scasb = 343, + op_scasw = 344, + op_scasd = 345, + op_scasq = 346, + op_seta = 347, + op_setae = 348, + op_setb = 349, + op_setbe = 350, + op_setc = 351, + op_sete = 352, + op_setg = 353, + op_setge = 354, + op_setl = 355, + op_setle = 356, + op_setna = 357, + op_setnae = 358, + op_setnb = 359, + op_setnbe = 360, + op_setnc = 361, + op_setne = 362, + op_setng = 363, + op_setnge = 364, + op_setnl = 365, + op_setnle = 366, + op_setno = 367, + op_setnp = 368, + op_setns = 369, + op_setnz = 370, + op_seto = 371, + op_setp = 372, + op_setpe = 373, + op_setpo = 374, + op_sets = 375, + op_setz = 376, + op_sfence = 377, + op_sgdt = 378, + op_shl = 379, + op_shld = 380, + op_shr = 381, + op_shrd = 382, + op_sidt = 383, + op_sldt = 384, + op_smsw = 385, + op_stc = 386, + op_std = 387, + op_sti = 388, + op_stos = 389, + op_stosb = 390, + op_stosw = 391, + op_stosd = 392, + op_stosq = 393, + op_str = 394, + op_sub = 395, + op_syscall = 396, + op_sysenter = 397, + op_sysexit = 398, + op_sysret = 399, + op_test = 400, + op_ud2 = 401, + op_verr = 402, + op_verw = 403, + op_wait = 404, + op_wbinvd = 405, + op_wrmsr = 406, + op_xadd = 407, + op_xchg = 408, + op_xlat = 409, + op_xlatb = 410, + op_xor = 411, + op_xrstor = 412, + op_xrstor64 = 413, + op_xsave = 414, + op_xsave64 = 415, + op_xsetbv = 416, + op_addpd = 417, + op_addps = 418, + op_addsd = 419, + op_addss = 420, + op_addsubpd = 421, + op_addsubps = 422, + op_andnpd = 423, + op_andnps = 424, + op_andpd = 425, + op_andps = 426, + op_blendpd = 427, + op_blendps = 428, + op_cmppd = 429, + op_cmpps = 430, + op_comisd = 431, + op_comiss = 432, + op_cvtdq2pd = 433, + op_cvtdq2ps = 434, + op_cvtpd2dq = 435, + op_cvtpd2pi = 436, + op_cvtpd2ps = 437, + op_cvtpi2pd = 438, + op_cvtpi2ps = 439, + op_cvtps2dq = 440, + op_cvtps2pd = 441, + op_cvtps2pi = 442, + op_cvtsd2si = 443, + op_cvtsd2ss = 444, + op_cvtsi2sd = 445, + op_cvtsi2ss = 446, + op_cvtss2sd = 447, + op_cvtss2si = 448, + op_cvttpd2dq = 449, + op_cvttpd2pi = 450, + op_cvttps2dq = 451, + op_cvttps2pi = 452, + op_cvttsd2si = 453, + op_cvttss2si = 454, + op_divpd = 455, + op_divps = 456, + op_divsd = 457, + op_divss = 458, + op_dppd = 459, + op_dpps = 460, + op_hsubpd = 461, + op_hsubps = 462, + op_insertps = 463, + op_lddqu = 464, + op_maskmovdqu = 465, + op_maskmovq = 466, + op_maxpd = 467, + op_maxps = 468, + op_maxsd = 469, + op_maxss = 470, + op_mfence = 471, + op_pause = 472, + op_minpd = 473, + op_minps = 474, + op_minsd = 475, + op_minss = 476, + op_monitor = 477, + op_movapd = 478, + op_movaps = 479, + op_movd = 480, + op_movq = 481, + op_movddup = 482, + op_movdq2q = 483, + op_movdqa = 484, + op_movdqu = 485, + op_movhlps = 486, + op_movhpd = 487, + op_movhps = 488, + op_movlhps = 489, + op_movlpd = 490, + op_movlps = 491, + op_movmskpd = 492, + op_movmskps = 493, + op_movntdq = 494, + op_movnti = 495, + op_movntpd = 496, + op_movntd = 497, + op_movntq = 498, + op_movq2dq = 499, + op_movshdup = 500, + op_movsldup = 501, + op_movss = 502, + op_movupd = 503, + op_movups = 504, + op_mpsadbw = 505, + op_mulpd = 506, + op_mulps = 507, + op_mulsd = 508, + op_mulss = 509, + op_orpd = 510, + op_orps = 511, + op_packssdw = 512, + op_packsswb = 513, + op_packusdw = 514, + op_paddb = 515, + op_paddd = 516, + op_paddq = 517, + op_paddsw = 518, + op_paddusb = 519, + op_paddusw = 520, + op_paddw = 521, + op_palignr = 522, + op_pand = 523, + op_pandn = 524, + op_pavgb = 525, + op_pavgw = 526, + op_pblendw = 527, + op_pcmpeqb = 528, + op_pcmpeqd = 529, + op_pcmpeqw = 530, + op_pcmpestri = 531, + op_pcmpestrm = 532, + op_pcmpgtb = 533, + op_pcmpgtd = 534, + op_pcmpgtw = 535, + op_pextrb = 536, + op_pextrd = 537, + op_pextrq = 538, + op_pextrw = 539, + op_pinsrb = 540, + op_pinsrd = 541, + op_pinsrq = 542, + op_pinsrw = 543, + op_pmaddwd = 544, + op_pmaxsw = 545, + op_pmaxub = 546, + op_pminsw = 547, + op_pminub = 548, + op_pmovmskb = 549, + op_pmulhuw = 550, + op_pmulhw = 551, + op_pmullw = 552, + op_pmuludq = 553, + op_psadbw = 554, + op_pshufd = 555, + op_pshufhw = 556, + op_pshuflw = 557, + op_pshufw = 558, + op_pslld = 559, + op_pslldq = 560, + op_psllq = 561, + op_psllw = 562, + op_psrad = 563, + op_psraw = 564, + op_psrld = 565, + op_psrldq = 566, + op_psrlq = 567, + op_psrlw = 568, + op_psubb = 569, + op_psubd = 570, + op_psubq = 571, + op_psubsb = 572, + op_psubsw = 573, + op_psubusb = 574, + op_psubusw = 575, + op_punpckhbw = 576, + op_punpckhdq = 577, + op_punpckhqdq = 578, + op_punpckhwd = 579, + op_punpcklbw = 580, + op_punpckldq = 581, + op_punpcklqdq = 582, + op_punpcklwd = 583, + op_pxor = 584, + op_rcpps = 585, + op_rcpss = 586, + op_roundpd = 587, + op_roundps = 588, + op_roundsd = 589, + op_roundss = 590, + op_rsqrtps = 591, + op_rsqrtss = 592, + op_shufpd = 593, + op_shufps = 594, + op_sqrtpd = 595, + op_sqrtps = 596, + op_sqrtsd = 597, + op_sqrtss = 598, + op_subpd = 599, + op_subps = 600, + op_subsd = 601, + op_subss = 602, + op_ucomisd = 603, + op_ucomiss = 604, + op_unpckhpd = 605, + op_unpckhps = 606, + op_unpcklpd = 607, + op_unpcklps = 608, + op_xorpd = 609, + op_xorps = 610, + op_invept = 611, + op_invvpid = 612, + op_vmcall = 613, + op_vmclear = 614, + op_vmlaunch = 615, + op_vmptrld = 616, + op_vmptrst = 617, + op_vmread = 618, + op_vmresume = 619, + op_vmwrite = 620, + op_vmxoff = 621, + op_vmxon = 622, + op_a16 = 623, + op_a32 = 624, + op_lock = 625, + op_o16 = 626, + op_o32 = 627, + op_rep = 628, + op_repe = 629, + op_repne = 630, + op_repnz = 631, + op_repz = 632, }; enum e_tk { @@ -754,7 +756,7 @@ enum e_tk { tk_tr7 = 1130, }; -extern const char * const opcodeTable[631]; +extern const char * const opcodeTable[633]; extern std::unordered_map tokenNames; diff --git a/src/oasm/x64Parser.cpp b/src/oasm/x64Parser.cpp index 457accef1..ba731a80e 100644 --- a/src/oasm/x64Parser.cpp +++ b/src/oasm/x64Parser.cpp @@ -799,530 +799,532 @@ void x64Parser::Init() opcodeTable["cmpxchg8b"] = 94; opcodeTable["cmpxchg16b"] = 95; opcodeTable["cpuid"] = 96; - opcodeTable["cqo"] = 97; - opcodeTable["cwd"] = 98; - opcodeTable["cwde"] = 99; - opcodeTable["daa"] = 100; - opcodeTable["das"] = 101; - opcodeTable["dec"] = 102; - opcodeTable["div"] = 103; - opcodeTable["enter"] = 104; - opcodeTable["esc"] = 105; - opcodeTable["f2xm1"] = 106; - opcodeTable["fabs"] = 107; - opcodeTable["fadd"] = 108; - opcodeTable["faddp"] = 109; - opcodeTable["fbld"] = 110; - opcodeTable["fbstp"] = 111; - opcodeTable["fchs"] = 112; - opcodeTable["fclex"] = 113; - opcodeTable["fnclex"] = 114; - opcodeTable["fcmovb"] = 115; - opcodeTable["fcmovbe"] = 116; - opcodeTable["fcmove"] = 117; - opcodeTable["fcmovnb"] = 118; - opcodeTable["fcmovnbe"] = 119; - opcodeTable["fcmovne"] = 120; - opcodeTable["fcmovnu"] = 121; - opcodeTable["fcmovu"] = 122; - opcodeTable["fcom"] = 123; - opcodeTable["fcomi"] = 124; - opcodeTable["fcomip"] = 125; - opcodeTable["fcomp"] = 126; - opcodeTable["fcompp"] = 127; - opcodeTable["fcos"] = 128; - opcodeTable["fdecstp"] = 129; - opcodeTable["fdisi"] = 130; - opcodeTable["fdiv"] = 131; - opcodeTable["fdivp"] = 132; - opcodeTable["fdivr"] = 133; - opcodeTable["fdivrp"] = 134; - opcodeTable["feni"] = 135; - opcodeTable["ffree"] = 136; - opcodeTable["ffreep"] = 137; - opcodeTable["fiadd"] = 138; - opcodeTable["ficom"] = 139; - opcodeTable["ficomp"] = 140; - opcodeTable["fidiv"] = 141; - opcodeTable["fidivr"] = 142; - opcodeTable["fild"] = 143; - opcodeTable["fimul"] = 144; - opcodeTable["fincstp"] = 145; - opcodeTable["finit"] = 146; - opcodeTable["fninit"] = 147; - opcodeTable["fist"] = 148; - opcodeTable["fistp"] = 149; - opcodeTable["fisub"] = 150; - opcodeTable["fisubr"] = 151; - opcodeTable["fld"] = 152; - opcodeTable["fld1"] = 153; - opcodeTable["fldcw"] = 154; - opcodeTable["fldenv"] = 155; - opcodeTable["fldl2e"] = 156; - opcodeTable["fldl2t"] = 157; - opcodeTable["fldlg2"] = 158; - opcodeTable["fldln2"] = 159; - opcodeTable["fldpi"] = 160; - opcodeTable["fldz"] = 161; - opcodeTable["fmul"] = 162; - opcodeTable["fmulp"] = 163; - opcodeTable["fnop"] = 164; - opcodeTable["fnsave"] = 165; - opcodeTable["fpatan"] = 166; - opcodeTable["fprem"] = 167; - opcodeTable["fprem1"] = 168; - opcodeTable["fptan"] = 169; - opcodeTable["frndint"] = 170; - opcodeTable["frstor"] = 171; - opcodeTable["fsave"] = 172; - opcodeTable["fscale"] = 173; - opcodeTable["fsetpm"] = 174; - opcodeTable["fsin"] = 175; - opcodeTable["fsincos"] = 176; - opcodeTable["fsqrt"] = 177; - opcodeTable["fst"] = 178; - opcodeTable["fstcw"] = 179; - opcodeTable["fnstcw"] = 180; - opcodeTable["fstenv"] = 181; - opcodeTable["fnstenv"] = 182; - opcodeTable["fstp"] = 183; - opcodeTable["fstsw"] = 184; - opcodeTable["fnstsw"] = 185; - opcodeTable["fsub"] = 186; - opcodeTable["fsubp"] = 187; - opcodeTable["fsubr"] = 188; - opcodeTable["fsubrp"] = 189; - opcodeTable["ftst"] = 190; - opcodeTable["fucom"] = 191; - opcodeTable["fucomi"] = 192; - opcodeTable["fucomip"] = 193; - opcodeTable["fucomp"] = 194; - opcodeTable["fucompp"] = 195; - opcodeTable["fwait"] = 196; - opcodeTable["fxam"] = 197; - opcodeTable["fxch"] = 198; - opcodeTable["fxch4"] = 199; - opcodeTable["fxch7"] = 200; - opcodeTable["fxrstor"] = 201; - opcodeTable["fxsave"] = 202; - opcodeTable["fxtract"] = 203; - opcodeTable["fyl2x"] = 204; - opcodeTable["fyl2xp1"] = 205; - opcodeTable["hlt"] = 206; - opcodeTable["icebp"] = 207; - opcodeTable["idiv"] = 208; - opcodeTable["imul"] = 209; - opcodeTable["in"] = 210; - opcodeTable["ins"] = 211; - opcodeTable["insb"] = 212; - opcodeTable["insw"] = 213; - opcodeTable["insd"] = 214; - opcodeTable["inc"] = 215; - opcodeTable["int"] = 216; - opcodeTable["int1"] = 217; - opcodeTable["int3"] = 218; - opcodeTable["into"] = 219; - opcodeTable["invd"] = 220; - opcodeTable["invlpg"] = 221; - opcodeTable["iret"] = 222; - opcodeTable["iretw"] = 223; - opcodeTable["iretd"] = 224; - opcodeTable["iretq"] = 225; - opcodeTable["ja"] = 226; - opcodeTable["jae"] = 227; - opcodeTable["jb"] = 228; - opcodeTable["jbe"] = 229; - opcodeTable["jc"] = 230; - opcodeTable["jcxz"] = 231; - opcodeTable["jecxz"] = 232; - opcodeTable["je"] = 233; - opcodeTable["jg"] = 234; - opcodeTable["jge"] = 235; - opcodeTable["jl"] = 236; - opcodeTable["jle"] = 237; - opcodeTable["jmp"] = 238; - opcodeTable["jna"] = 239; - opcodeTable["jnae"] = 240; - opcodeTable["jnb"] = 241; - opcodeTable["jnbe"] = 242; - opcodeTable["jnc"] = 243; - opcodeTable["jne"] = 244; - opcodeTable["jng"] = 245; - opcodeTable["jnge"] = 246; - opcodeTable["jnl"] = 247; - opcodeTable["jnle"] = 248; - opcodeTable["jno"] = 249; - opcodeTable["jnp"] = 250; - opcodeTable["jns"] = 251; - opcodeTable["jnz"] = 252; - opcodeTable["jo"] = 253; - opcodeTable["jp"] = 254; - opcodeTable["jpe"] = 255; - opcodeTable["jpo"] = 256; - opcodeTable["js"] = 257; - opcodeTable["jz"] = 258; - opcodeTable["lahf"] = 259; - opcodeTable["lar"] = 260; - opcodeTable["lds"] = 261; - opcodeTable["lea"] = 262; - opcodeTable["leave"] = 263; - opcodeTable["les"] = 264; - opcodeTable["lfence"] = 265; - opcodeTable["lfs"] = 266; - opcodeTable["lgdt"] = 267; - opcodeTable["lgs"] = 268; - opcodeTable["lidt"] = 269; - opcodeTable["lldt"] = 270; - opcodeTable["lmsw"] = 271; - opcodeTable["lods"] = 272; - opcodeTable["lodsb"] = 273; - opcodeTable["lodsw"] = 274; - opcodeTable["lodsd"] = 275; - opcodeTable["lodsq"] = 276; - opcodeTable["loop"] = 277; - opcodeTable["loope"] = 278; - opcodeTable["loopne"] = 279; - opcodeTable["loopnz"] = 280; - opcodeTable["loopz"] = 281; - opcodeTable["lsl"] = 282; - opcodeTable["lss"] = 283; - opcodeTable["ltr"] = 284; - opcodeTable["mov"] = 285; - opcodeTable["movs"] = 286; - opcodeTable["movbe"] = 287; - opcodeTable["movsb"] = 288; - opcodeTable["movsw"] = 289; - opcodeTable["movsd"] = 290; - opcodeTable["movsq"] = 291; - opcodeTable["movsx"] = 292; - opcodeTable["movzx"] = 293; - opcodeTable["movsxd"] = 294; - opcodeTable["mul"] = 295; - opcodeTable["neg"] = 296; - opcodeTable["nop"] = 297; - opcodeTable["not"] = 298; - opcodeTable["or"] = 299; - opcodeTable["out"] = 300; - opcodeTable["outs"] = 301; - opcodeTable["outsb"] = 302; - opcodeTable["outsw"] = 303; - opcodeTable["outsd"] = 304; - opcodeTable["pop"] = 305; - opcodeTable["popa"] = 306; - opcodeTable["popaw"] = 307; - opcodeTable["popad"] = 308; - opcodeTable["popcnt"] = 309; - opcodeTable["popf"] = 310; - opcodeTable["popfw"] = 311; - opcodeTable["popfd"] = 312; - opcodeTable["popfq"] = 313; - opcodeTable["prefetchnta"] = 314; - opcodeTable["prefetcht0"] = 315; - opcodeTable["prefetcht1"] = 316; - opcodeTable["prefetcht2"] = 317; - opcodeTable["push"] = 318; - opcodeTable["pusha"] = 319; - opcodeTable["pushaw"] = 320; - opcodeTable["pushad"] = 321; - opcodeTable["pushf"] = 322; - opcodeTable["pushfw"] = 323; - opcodeTable["pushfd"] = 324; - opcodeTable["pushfq"] = 325; - opcodeTable["rcl"] = 326; - opcodeTable["rcr"] = 327; - opcodeTable["rdmsr"] = 328; - opcodeTable["rdpmc"] = 329; - opcodeTable["rdtsc"] = 330; - opcodeTable["ret"] = 331; - opcodeTable["retf"] = 332; - opcodeTable["rol"] = 333; - opcodeTable["ror"] = 334; - opcodeTable["rsm"] = 335; - opcodeTable["sahf"] = 336; - opcodeTable["sal"] = 337; - opcodeTable["sar"] = 338; - opcodeTable["sbb"] = 339; - opcodeTable["scas"] = 340; - opcodeTable["scasb"] = 341; - opcodeTable["scasw"] = 342; - opcodeTable["scasd"] = 343; - opcodeTable["scasq"] = 344; - opcodeTable["seta"] = 345; - opcodeTable["setae"] = 346; - opcodeTable["setb"] = 347; - opcodeTable["setbe"] = 348; - opcodeTable["setc"] = 349; - opcodeTable["sete"] = 350; - opcodeTable["setg"] = 351; - opcodeTable["setge"] = 352; - opcodeTable["setl"] = 353; - opcodeTable["setle"] = 354; - opcodeTable["setna"] = 355; - opcodeTable["setnae"] = 356; - opcodeTable["setnb"] = 357; - opcodeTable["setnbe"] = 358; - opcodeTable["setnc"] = 359; - opcodeTable["setne"] = 360; - opcodeTable["setng"] = 361; - opcodeTable["setnge"] = 362; - opcodeTable["setnl"] = 363; - opcodeTable["setnle"] = 364; - opcodeTable["setno"] = 365; - opcodeTable["setnp"] = 366; - opcodeTable["setns"] = 367; - opcodeTable["setnz"] = 368; - opcodeTable["seto"] = 369; - opcodeTable["setp"] = 370; - opcodeTable["setpe"] = 371; - opcodeTable["setpo"] = 372; - opcodeTable["sets"] = 373; - opcodeTable["setz"] = 374; - opcodeTable["sfence"] = 375; - opcodeTable["sgdt"] = 376; - opcodeTable["shl"] = 377; - opcodeTable["shld"] = 378; - opcodeTable["shr"] = 379; - opcodeTable["shrd"] = 380; - opcodeTable["sidt"] = 381; - opcodeTable["sldt"] = 382; - opcodeTable["smsw"] = 383; - opcodeTable["stc"] = 384; - opcodeTable["std"] = 385; - opcodeTable["sti"] = 386; - opcodeTable["stos"] = 387; - opcodeTable["stosb"] = 388; - opcodeTable["stosw"] = 389; - opcodeTable["stosd"] = 390; - opcodeTable["stosq"] = 391; - opcodeTable["str"] = 392; - opcodeTable["sub"] = 393; - opcodeTable["syscall"] = 394; - opcodeTable["sysenter"] = 395; - opcodeTable["sysexit"] = 396; - opcodeTable["sysret"] = 397; - opcodeTable["test"] = 398; - opcodeTable["ud2"] = 399; - opcodeTable["verr"] = 400; - opcodeTable["verw"] = 401; - opcodeTable["wait"] = 402; - opcodeTable["wbinvd"] = 403; - opcodeTable["wrmsr"] = 404; - opcodeTable["xadd"] = 405; - opcodeTable["xchg"] = 406; - opcodeTable["xlat"] = 407; - opcodeTable["xlatb"] = 408; - opcodeTable["xor"] = 409; - opcodeTable["xrstor"] = 410; - opcodeTable["xrstor64"] = 411; - opcodeTable["xsave"] = 412; - opcodeTable["xsave64"] = 413; - opcodeTable["xsetbv"] = 414; - opcodeTable["addpd"] = 415; - opcodeTable["addps"] = 416; - opcodeTable["addsd"] = 417; - opcodeTable["addss"] = 418; - opcodeTable["addsubpd"] = 419; - opcodeTable["addsubps"] = 420; - opcodeTable["andnpd"] = 421; - opcodeTable["andnps"] = 422; - opcodeTable["andpd"] = 423; - opcodeTable["andps"] = 424; - opcodeTable["blendpd"] = 425; - opcodeTable["blendps"] = 426; - opcodeTable["cmppd"] = 427; - opcodeTable["cmpps"] = 428; - opcodeTable["comisd"] = 429; - opcodeTable["comiss"] = 430; - opcodeTable["cvtdq2pd"] = 431; - opcodeTable["cvtdq2ps"] = 432; - opcodeTable["cvtpd2dq"] = 433; - opcodeTable["cvtpd2pi"] = 434; - opcodeTable["cvtpd2ps"] = 435; - opcodeTable["cvtpi2pd"] = 436; - opcodeTable["cvtpi2ps"] = 437; - opcodeTable["cvtps2dq"] = 438; - opcodeTable["cvtps2pd"] = 439; - opcodeTable["cvtps2pi"] = 440; - opcodeTable["cvtsd2si"] = 441; - opcodeTable["cvtsd2ss"] = 442; - opcodeTable["cvtsi2sd"] = 443; - opcodeTable["cvtsi2ss"] = 444; - opcodeTable["cvtss2sd"] = 445; - opcodeTable["cvtss2si"] = 446; - opcodeTable["cvttpd2dq"] = 447; - opcodeTable["cvttpd2pi"] = 448; - opcodeTable["cvttps2dq"] = 449; - opcodeTable["cvttps2pi"] = 450; - opcodeTable["cvttsd2si"] = 451; - opcodeTable["cvttss2si"] = 452; - opcodeTable["divpd"] = 453; - opcodeTable["divps"] = 454; - opcodeTable["divsd"] = 455; - opcodeTable["divss"] = 456; - opcodeTable["dppd"] = 457; - opcodeTable["dpps"] = 458; - opcodeTable["hsubpd"] = 459; - opcodeTable["hsubps"] = 460; - opcodeTable["insertps"] = 461; - opcodeTable["lddqu"] = 462; - opcodeTable["maskmovdqu"] = 463; - opcodeTable["maskmovq"] = 464; - opcodeTable["maxpd"] = 465; - opcodeTable["maxps"] = 466; - opcodeTable["maxsd"] = 467; - opcodeTable["maxss"] = 468; - opcodeTable["mfence"] = 469; - opcodeTable["pause"] = 470; - opcodeTable["minpd"] = 471; - opcodeTable["minps"] = 472; - opcodeTable["minsd"] = 473; - opcodeTable["minss"] = 474; - opcodeTable["monitor"] = 475; - opcodeTable["movapd"] = 476; - opcodeTable["movaps"] = 477; - opcodeTable["movd"] = 478; - opcodeTable["movq"] = 479; - opcodeTable["movddup"] = 480; - opcodeTable["movdq2q"] = 481; - opcodeTable["movdqa"] = 482; - opcodeTable["movdqu"] = 483; - opcodeTable["movhlps"] = 484; - opcodeTable["movhpd"] = 485; - opcodeTable["movhps"] = 486; - opcodeTable["movlhps"] = 487; - opcodeTable["movlpd"] = 488; - opcodeTable["movlps"] = 489; - opcodeTable["movmskpd"] = 490; - opcodeTable["movmskps"] = 491; - opcodeTable["movntdq"] = 492; - opcodeTable["movnti"] = 493; - opcodeTable["movntpd"] = 494; - opcodeTable["movntd"] = 495; - opcodeTable["movntq"] = 496; - opcodeTable["movq2dq"] = 497; - opcodeTable["movshdup"] = 498; - opcodeTable["movsldup"] = 499; - opcodeTable["movss"] = 500; - opcodeTable["movupd"] = 501; - opcodeTable["movups"] = 502; - opcodeTable["mpsadbw"] = 503; - opcodeTable["mulpd"] = 504; - opcodeTable["mulps"] = 505; - opcodeTable["mulsd"] = 506; - opcodeTable["mulss"] = 507; - opcodeTable["orpd"] = 508; - opcodeTable["orps"] = 509; - opcodeTable["packssdw"] = 510; - opcodeTable["packsswb"] = 511; - opcodeTable["packusdw"] = 512; - opcodeTable["paddb"] = 513; - opcodeTable["paddd"] = 514; - opcodeTable["paddq"] = 515; - opcodeTable["paddsw"] = 516; - opcodeTable["paddusb"] = 517; - opcodeTable["paddusw"] = 518; - opcodeTable["paddw"] = 519; - opcodeTable["palignr"] = 520; - opcodeTable["pand"] = 521; - opcodeTable["pandn"] = 522; - opcodeTable["pavgb"] = 523; - opcodeTable["pavgw"] = 524; - opcodeTable["pblendw"] = 525; - opcodeTable["pcmpeqb"] = 526; - opcodeTable["pcmpeqd"] = 527; - opcodeTable["pcmpeqw"] = 528; - opcodeTable["pcmpestri"] = 529; - opcodeTable["pcmpestrm"] = 530; - opcodeTable["pcmpgtb"] = 531; - opcodeTable["pcmpgtd"] = 532; - opcodeTable["pcmpgtw"] = 533; - opcodeTable["pextrb"] = 534; - opcodeTable["pextrd"] = 535; - opcodeTable["pextrq"] = 536; - opcodeTable["pextrw"] = 537; - opcodeTable["pinsrb"] = 538; - opcodeTable["pinsrd"] = 539; - opcodeTable["pinsrq"] = 540; - opcodeTable["pinsrw"] = 541; - opcodeTable["pmaddwd"] = 542; - opcodeTable["pmaxsw"] = 543; - opcodeTable["pmaxub"] = 544; - opcodeTable["pminsw"] = 545; - opcodeTable["pminub"] = 546; - opcodeTable["pmovmskb"] = 547; - opcodeTable["pmulhuw"] = 548; - opcodeTable["pmulhw"] = 549; - opcodeTable["pmullw"] = 550; - opcodeTable["pmuludq"] = 551; - opcodeTable["psadbw"] = 552; - opcodeTable["pshufd"] = 553; - opcodeTable["pshufhw"] = 554; - opcodeTable["pshuflw"] = 555; - opcodeTable["pshufw"] = 556; - opcodeTable["pslld"] = 557; - opcodeTable["pslldq"] = 558; - opcodeTable["psllq"] = 559; - opcodeTable["psllw"] = 560; - opcodeTable["psrad"] = 561; - opcodeTable["psraw"] = 562; - opcodeTable["psrld"] = 563; - opcodeTable["psrldq"] = 564; - opcodeTable["psrlq"] = 565; - opcodeTable["psrlw"] = 566; - opcodeTable["psubb"] = 567; - opcodeTable["psubd"] = 568; - opcodeTable["psubq"] = 569; - opcodeTable["psubsb"] = 570; - opcodeTable["psubsw"] = 571; - opcodeTable["psubusb"] = 572; - opcodeTable["psubusw"] = 573; - opcodeTable["punpckhbw"] = 574; - opcodeTable["punpckhdq"] = 575; - opcodeTable["punpckhqdq"] = 576; - opcodeTable["punpckhwd"] = 577; - opcodeTable["punpcklbw"] = 578; - opcodeTable["punpckldq"] = 579; - opcodeTable["punpcklqdq"] = 580; - opcodeTable["punpcklwd"] = 581; - opcodeTable["pxor"] = 582; - opcodeTable["rcpps"] = 583; - opcodeTable["rcpss"] = 584; - opcodeTable["roundpd"] = 585; - opcodeTable["roundps"] = 586; - opcodeTable["roundsd"] = 587; - opcodeTable["roundss"] = 588; - opcodeTable["rsqrtps"] = 589; - opcodeTable["rsqrtss"] = 590; - opcodeTable["shufpd"] = 591; - opcodeTable["shufps"] = 592; - opcodeTable["sqrtpd"] = 593; - opcodeTable["sqrtps"] = 594; - opcodeTable["sqrtsd"] = 595; - opcodeTable["sqrtss"] = 596; - opcodeTable["subpd"] = 597; - opcodeTable["subps"] = 598; - opcodeTable["subsd"] = 599; - opcodeTable["subss"] = 600; - opcodeTable["ucomisd"] = 601; - opcodeTable["ucomiss"] = 602; - opcodeTable["unpckhpd"] = 603; - opcodeTable["unpckhps"] = 604; - opcodeTable["unpcklpd"] = 605; - opcodeTable["unpcklps"] = 606; - opcodeTable["xorpd"] = 607; - opcodeTable["xorps"] = 608; - opcodeTable["invept"] = 609; - opcodeTable["invvpid"] = 610; - opcodeTable["vmcall"] = 611; - opcodeTable["vmclear"] = 612; - opcodeTable["vmlaunch"] = 613; - opcodeTable["vmptrld"] = 614; - opcodeTable["vmptrst"] = 615; - opcodeTable["vmread"] = 616; - opcodeTable["vmresume"] = 617; - opcodeTable["vmwrite"] = 618; - opcodeTable["vmxoff"] = 619; - opcodeTable["vmxon"] = 620; + opcodeTable["clflush"] = 97; + opcodeTable["clflushopt"] = 98; + opcodeTable["cqo"] = 99; + opcodeTable["cwd"] = 100; + opcodeTable["cwde"] = 101; + opcodeTable["daa"] = 102; + opcodeTable["das"] = 103; + opcodeTable["dec"] = 104; + opcodeTable["div"] = 105; + opcodeTable["enter"] = 106; + opcodeTable["esc"] = 107; + opcodeTable["f2xm1"] = 108; + opcodeTable["fabs"] = 109; + opcodeTable["fadd"] = 110; + opcodeTable["faddp"] = 111; + opcodeTable["fbld"] = 112; + opcodeTable["fbstp"] = 113; + opcodeTable["fchs"] = 114; + opcodeTable["fclex"] = 115; + opcodeTable["fnclex"] = 116; + opcodeTable["fcmovb"] = 117; + opcodeTable["fcmovbe"] = 118; + opcodeTable["fcmove"] = 119; + opcodeTable["fcmovnb"] = 120; + opcodeTable["fcmovnbe"] = 121; + opcodeTable["fcmovne"] = 122; + opcodeTable["fcmovnu"] = 123; + opcodeTable["fcmovu"] = 124; + opcodeTable["fcom"] = 125; + opcodeTable["fcomi"] = 126; + opcodeTable["fcomip"] = 127; + opcodeTable["fcomp"] = 128; + opcodeTable["fcompp"] = 129; + opcodeTable["fcos"] = 130; + opcodeTable["fdecstp"] = 131; + opcodeTable["fdisi"] = 132; + opcodeTable["fdiv"] = 133; + opcodeTable["fdivp"] = 134; + opcodeTable["fdivr"] = 135; + opcodeTable["fdivrp"] = 136; + opcodeTable["feni"] = 137; + opcodeTable["ffree"] = 138; + opcodeTable["ffreep"] = 139; + opcodeTable["fiadd"] = 140; + opcodeTable["ficom"] = 141; + opcodeTable["ficomp"] = 142; + opcodeTable["fidiv"] = 143; + opcodeTable["fidivr"] = 144; + opcodeTable["fild"] = 145; + opcodeTable["fimul"] = 146; + opcodeTable["fincstp"] = 147; + opcodeTable["finit"] = 148; + opcodeTable["fninit"] = 149; + opcodeTable["fist"] = 150; + opcodeTable["fistp"] = 151; + opcodeTable["fisub"] = 152; + opcodeTable["fisubr"] = 153; + opcodeTable["fld"] = 154; + opcodeTable["fld1"] = 155; + opcodeTable["fldcw"] = 156; + opcodeTable["fldenv"] = 157; + opcodeTable["fldl2e"] = 158; + opcodeTable["fldl2t"] = 159; + opcodeTable["fldlg2"] = 160; + opcodeTable["fldln2"] = 161; + opcodeTable["fldpi"] = 162; + opcodeTable["fldz"] = 163; + opcodeTable["fmul"] = 164; + opcodeTable["fmulp"] = 165; + opcodeTable["fnop"] = 166; + opcodeTable["fnsave"] = 167; + opcodeTable["fpatan"] = 168; + opcodeTable["fprem"] = 169; + opcodeTable["fprem1"] = 170; + opcodeTable["fptan"] = 171; + opcodeTable["frndint"] = 172; + opcodeTable["frstor"] = 173; + opcodeTable["fsave"] = 174; + opcodeTable["fscale"] = 175; + opcodeTable["fsetpm"] = 176; + opcodeTable["fsin"] = 177; + opcodeTable["fsincos"] = 178; + opcodeTable["fsqrt"] = 179; + opcodeTable["fst"] = 180; + opcodeTable["fstcw"] = 181; + opcodeTable["fnstcw"] = 182; + opcodeTable["fstenv"] = 183; + opcodeTable["fnstenv"] = 184; + opcodeTable["fstp"] = 185; + opcodeTable["fstsw"] = 186; + opcodeTable["fnstsw"] = 187; + opcodeTable["fsub"] = 188; + opcodeTable["fsubp"] = 189; + opcodeTable["fsubr"] = 190; + opcodeTable["fsubrp"] = 191; + opcodeTable["ftst"] = 192; + opcodeTable["fucom"] = 193; + opcodeTable["fucomi"] = 194; + opcodeTable["fucomip"] = 195; + opcodeTable["fucomp"] = 196; + opcodeTable["fucompp"] = 197; + opcodeTable["fwait"] = 198; + opcodeTable["fxam"] = 199; + opcodeTable["fxch"] = 200; + opcodeTable["fxch4"] = 201; + opcodeTable["fxch7"] = 202; + opcodeTable["fxrstor"] = 203; + opcodeTable["fxsave"] = 204; + opcodeTable["fxtract"] = 205; + opcodeTable["fyl2x"] = 206; + opcodeTable["fyl2xp1"] = 207; + opcodeTable["hlt"] = 208; + opcodeTable["icebp"] = 209; + opcodeTable["idiv"] = 210; + opcodeTable["imul"] = 211; + opcodeTable["in"] = 212; + opcodeTable["ins"] = 213; + opcodeTable["insb"] = 214; + opcodeTable["insw"] = 215; + opcodeTable["insd"] = 216; + opcodeTable["inc"] = 217; + opcodeTable["int"] = 218; + opcodeTable["int1"] = 219; + opcodeTable["int3"] = 220; + opcodeTable["into"] = 221; + opcodeTable["invd"] = 222; + opcodeTable["invlpg"] = 223; + opcodeTable["iret"] = 224; + opcodeTable["iretw"] = 225; + opcodeTable["iretd"] = 226; + opcodeTable["iretq"] = 227; + opcodeTable["ja"] = 228; + opcodeTable["jae"] = 229; + opcodeTable["jb"] = 230; + opcodeTable["jbe"] = 231; + opcodeTable["jc"] = 232; + opcodeTable["jcxz"] = 233; + opcodeTable["jecxz"] = 234; + opcodeTable["je"] = 235; + opcodeTable["jg"] = 236; + opcodeTable["jge"] = 237; + opcodeTable["jl"] = 238; + opcodeTable["jle"] = 239; + opcodeTable["jmp"] = 240; + opcodeTable["jna"] = 241; + opcodeTable["jnae"] = 242; + opcodeTable["jnb"] = 243; + opcodeTable["jnbe"] = 244; + opcodeTable["jnc"] = 245; + opcodeTable["jne"] = 246; + opcodeTable["jng"] = 247; + opcodeTable["jnge"] = 248; + opcodeTable["jnl"] = 249; + opcodeTable["jnle"] = 250; + opcodeTable["jno"] = 251; + opcodeTable["jnp"] = 252; + opcodeTable["jns"] = 253; + opcodeTable["jnz"] = 254; + opcodeTable["jo"] = 255; + opcodeTable["jp"] = 256; + opcodeTable["jpe"] = 257; + opcodeTable["jpo"] = 258; + opcodeTable["js"] = 259; + opcodeTable["jz"] = 260; + opcodeTable["lahf"] = 261; + opcodeTable["lar"] = 262; + opcodeTable["lds"] = 263; + opcodeTable["lea"] = 264; + opcodeTable["leave"] = 265; + opcodeTable["les"] = 266; + opcodeTable["lfence"] = 267; + opcodeTable["lfs"] = 268; + opcodeTable["lgdt"] = 269; + opcodeTable["lgs"] = 270; + opcodeTable["lidt"] = 271; + opcodeTable["lldt"] = 272; + opcodeTable["lmsw"] = 273; + opcodeTable["lods"] = 274; + opcodeTable["lodsb"] = 275; + opcodeTable["lodsw"] = 276; + opcodeTable["lodsd"] = 277; + opcodeTable["lodsq"] = 278; + opcodeTable["loop"] = 279; + opcodeTable["loope"] = 280; + opcodeTable["loopne"] = 281; + opcodeTable["loopnz"] = 282; + opcodeTable["loopz"] = 283; + opcodeTable["lsl"] = 284; + opcodeTable["lss"] = 285; + opcodeTable["ltr"] = 286; + opcodeTable["mov"] = 287; + opcodeTable["movs"] = 288; + opcodeTable["movbe"] = 289; + opcodeTable["movsb"] = 290; + opcodeTable["movsw"] = 291; + opcodeTable["movsd"] = 292; + opcodeTable["movsq"] = 293; + opcodeTable["movsx"] = 294; + opcodeTable["movzx"] = 295; + opcodeTable["movsxd"] = 296; + opcodeTable["mul"] = 297; + opcodeTable["neg"] = 298; + opcodeTable["nop"] = 299; + opcodeTable["not"] = 300; + opcodeTable["or"] = 301; + opcodeTable["out"] = 302; + opcodeTable["outs"] = 303; + opcodeTable["outsb"] = 304; + opcodeTable["outsw"] = 305; + opcodeTable["outsd"] = 306; + opcodeTable["pop"] = 307; + opcodeTable["popa"] = 308; + opcodeTable["popaw"] = 309; + opcodeTable["popad"] = 310; + opcodeTable["popcnt"] = 311; + opcodeTable["popf"] = 312; + opcodeTable["popfw"] = 313; + opcodeTable["popfd"] = 314; + opcodeTable["popfq"] = 315; + opcodeTable["prefetchnta"] = 316; + opcodeTable["prefetcht0"] = 317; + opcodeTable["prefetcht1"] = 318; + opcodeTable["prefetcht2"] = 319; + opcodeTable["push"] = 320; + opcodeTable["pusha"] = 321; + opcodeTable["pushaw"] = 322; + opcodeTable["pushad"] = 323; + opcodeTable["pushf"] = 324; + opcodeTable["pushfw"] = 325; + opcodeTable["pushfd"] = 326; + opcodeTable["pushfq"] = 327; + opcodeTable["rcl"] = 328; + opcodeTable["rcr"] = 329; + opcodeTable["rdmsr"] = 330; + opcodeTable["rdpmc"] = 331; + opcodeTable["rdtsc"] = 332; + opcodeTable["ret"] = 333; + opcodeTable["retf"] = 334; + opcodeTable["rol"] = 335; + opcodeTable["ror"] = 336; + opcodeTable["rsm"] = 337; + opcodeTable["sahf"] = 338; + opcodeTable["sal"] = 339; + opcodeTable["sar"] = 340; + opcodeTable["sbb"] = 341; + opcodeTable["scas"] = 342; + opcodeTable["scasb"] = 343; + opcodeTable["scasw"] = 344; + opcodeTable["scasd"] = 345; + opcodeTable["scasq"] = 346; + opcodeTable["seta"] = 347; + opcodeTable["setae"] = 348; + opcodeTable["setb"] = 349; + opcodeTable["setbe"] = 350; + opcodeTable["setc"] = 351; + opcodeTable["sete"] = 352; + opcodeTable["setg"] = 353; + opcodeTable["setge"] = 354; + opcodeTable["setl"] = 355; + opcodeTable["setle"] = 356; + opcodeTable["setna"] = 357; + opcodeTable["setnae"] = 358; + opcodeTable["setnb"] = 359; + opcodeTable["setnbe"] = 360; + opcodeTable["setnc"] = 361; + opcodeTable["setne"] = 362; + opcodeTable["setng"] = 363; + opcodeTable["setnge"] = 364; + opcodeTable["setnl"] = 365; + opcodeTable["setnle"] = 366; + opcodeTable["setno"] = 367; + opcodeTable["setnp"] = 368; + opcodeTable["setns"] = 369; + opcodeTable["setnz"] = 370; + opcodeTable["seto"] = 371; + opcodeTable["setp"] = 372; + opcodeTable["setpe"] = 373; + opcodeTable["setpo"] = 374; + opcodeTable["sets"] = 375; + opcodeTable["setz"] = 376; + opcodeTable["sfence"] = 377; + opcodeTable["sgdt"] = 378; + opcodeTable["shl"] = 379; + opcodeTable["shld"] = 380; + opcodeTable["shr"] = 381; + opcodeTable["shrd"] = 382; + opcodeTable["sidt"] = 383; + opcodeTable["sldt"] = 384; + opcodeTable["smsw"] = 385; + opcodeTable["stc"] = 386; + opcodeTable["std"] = 387; + opcodeTable["sti"] = 388; + opcodeTable["stos"] = 389; + opcodeTable["stosb"] = 390; + opcodeTable["stosw"] = 391; + opcodeTable["stosd"] = 392; + opcodeTable["stosq"] = 393; + opcodeTable["str"] = 394; + opcodeTable["sub"] = 395; + opcodeTable["syscall"] = 396; + opcodeTable["sysenter"] = 397; + opcodeTable["sysexit"] = 398; + opcodeTable["sysret"] = 399; + opcodeTable["test"] = 400; + opcodeTable["ud2"] = 401; + opcodeTable["verr"] = 402; + opcodeTable["verw"] = 403; + opcodeTable["wait"] = 404; + opcodeTable["wbinvd"] = 405; + opcodeTable["wrmsr"] = 406; + opcodeTable["xadd"] = 407; + opcodeTable["xchg"] = 408; + opcodeTable["xlat"] = 409; + opcodeTable["xlatb"] = 410; + opcodeTable["xor"] = 411; + opcodeTable["xrstor"] = 412; + opcodeTable["xrstor64"] = 413; + opcodeTable["xsave"] = 414; + opcodeTable["xsave64"] = 415; + opcodeTable["xsetbv"] = 416; + opcodeTable["addpd"] = 417; + opcodeTable["addps"] = 418; + opcodeTable["addsd"] = 419; + opcodeTable["addss"] = 420; + opcodeTable["addsubpd"] = 421; + opcodeTable["addsubps"] = 422; + opcodeTable["andnpd"] = 423; + opcodeTable["andnps"] = 424; + opcodeTable["andpd"] = 425; + opcodeTable["andps"] = 426; + opcodeTable["blendpd"] = 427; + opcodeTable["blendps"] = 428; + opcodeTable["cmppd"] = 429; + opcodeTable["cmpps"] = 430; + opcodeTable["comisd"] = 431; + opcodeTable["comiss"] = 432; + opcodeTable["cvtdq2pd"] = 433; + opcodeTable["cvtdq2ps"] = 434; + opcodeTable["cvtpd2dq"] = 435; + opcodeTable["cvtpd2pi"] = 436; + opcodeTable["cvtpd2ps"] = 437; + opcodeTable["cvtpi2pd"] = 438; + opcodeTable["cvtpi2ps"] = 439; + opcodeTable["cvtps2dq"] = 440; + opcodeTable["cvtps2pd"] = 441; + opcodeTable["cvtps2pi"] = 442; + opcodeTable["cvtsd2si"] = 443; + opcodeTable["cvtsd2ss"] = 444; + opcodeTable["cvtsi2sd"] = 445; + opcodeTable["cvtsi2ss"] = 446; + opcodeTable["cvtss2sd"] = 447; + opcodeTable["cvtss2si"] = 448; + opcodeTable["cvttpd2dq"] = 449; + opcodeTable["cvttpd2pi"] = 450; + opcodeTable["cvttps2dq"] = 451; + opcodeTable["cvttps2pi"] = 452; + opcodeTable["cvttsd2si"] = 453; + opcodeTable["cvttss2si"] = 454; + opcodeTable["divpd"] = 455; + opcodeTable["divps"] = 456; + opcodeTable["divsd"] = 457; + opcodeTable["divss"] = 458; + opcodeTable["dppd"] = 459; + opcodeTable["dpps"] = 460; + opcodeTable["hsubpd"] = 461; + opcodeTable["hsubps"] = 462; + opcodeTable["insertps"] = 463; + opcodeTable["lddqu"] = 464; + opcodeTable["maskmovdqu"] = 465; + opcodeTable["maskmovq"] = 466; + opcodeTable["maxpd"] = 467; + opcodeTable["maxps"] = 468; + opcodeTable["maxsd"] = 469; + opcodeTable["maxss"] = 470; + opcodeTable["mfence"] = 471; + opcodeTable["pause"] = 472; + opcodeTable["minpd"] = 473; + opcodeTable["minps"] = 474; + opcodeTable["minsd"] = 475; + opcodeTable["minss"] = 476; + opcodeTable["monitor"] = 477; + opcodeTable["movapd"] = 478; + opcodeTable["movaps"] = 479; + opcodeTable["movd"] = 480; + opcodeTable["movq"] = 481; + opcodeTable["movddup"] = 482; + opcodeTable["movdq2q"] = 483; + opcodeTable["movdqa"] = 484; + opcodeTable["movdqu"] = 485; + opcodeTable["movhlps"] = 486; + opcodeTable["movhpd"] = 487; + opcodeTable["movhps"] = 488; + opcodeTable["movlhps"] = 489; + opcodeTable["movlpd"] = 490; + opcodeTable["movlps"] = 491; + opcodeTable["movmskpd"] = 492; + opcodeTable["movmskps"] = 493; + opcodeTable["movntdq"] = 494; + opcodeTable["movnti"] = 495; + opcodeTable["movntpd"] = 496; + opcodeTable["movntd"] = 497; + opcodeTable["movntq"] = 498; + opcodeTable["movq2dq"] = 499; + opcodeTable["movshdup"] = 500; + opcodeTable["movsldup"] = 501; + opcodeTable["movss"] = 502; + opcodeTable["movupd"] = 503; + opcodeTable["movups"] = 504; + opcodeTable["mpsadbw"] = 505; + opcodeTable["mulpd"] = 506; + opcodeTable["mulps"] = 507; + opcodeTable["mulsd"] = 508; + opcodeTable["mulss"] = 509; + opcodeTable["orpd"] = 510; + opcodeTable["orps"] = 511; + opcodeTable["packssdw"] = 512; + opcodeTable["packsswb"] = 513; + opcodeTable["packusdw"] = 514; + opcodeTable["paddb"] = 515; + opcodeTable["paddd"] = 516; + opcodeTable["paddq"] = 517; + opcodeTable["paddsw"] = 518; + opcodeTable["paddusb"] = 519; + opcodeTable["paddusw"] = 520; + opcodeTable["paddw"] = 521; + opcodeTable["palignr"] = 522; + opcodeTable["pand"] = 523; + opcodeTable["pandn"] = 524; + opcodeTable["pavgb"] = 525; + opcodeTable["pavgw"] = 526; + opcodeTable["pblendw"] = 527; + opcodeTable["pcmpeqb"] = 528; + opcodeTable["pcmpeqd"] = 529; + opcodeTable["pcmpeqw"] = 530; + opcodeTable["pcmpestri"] = 531; + opcodeTable["pcmpestrm"] = 532; + opcodeTable["pcmpgtb"] = 533; + opcodeTable["pcmpgtd"] = 534; + opcodeTable["pcmpgtw"] = 535; + opcodeTable["pextrb"] = 536; + opcodeTable["pextrd"] = 537; + opcodeTable["pextrq"] = 538; + opcodeTable["pextrw"] = 539; + opcodeTable["pinsrb"] = 540; + opcodeTable["pinsrd"] = 541; + opcodeTable["pinsrq"] = 542; + opcodeTable["pinsrw"] = 543; + opcodeTable["pmaddwd"] = 544; + opcodeTable["pmaxsw"] = 545; + opcodeTable["pmaxub"] = 546; + opcodeTable["pminsw"] = 547; + opcodeTable["pminub"] = 548; + opcodeTable["pmovmskb"] = 549; + opcodeTable["pmulhuw"] = 550; + opcodeTable["pmulhw"] = 551; + opcodeTable["pmullw"] = 552; + opcodeTable["pmuludq"] = 553; + opcodeTable["psadbw"] = 554; + opcodeTable["pshufd"] = 555; + opcodeTable["pshufhw"] = 556; + opcodeTable["pshuflw"] = 557; + opcodeTable["pshufw"] = 558; + opcodeTable["pslld"] = 559; + opcodeTable["pslldq"] = 560; + opcodeTable["psllq"] = 561; + opcodeTable["psllw"] = 562; + opcodeTable["psrad"] = 563; + opcodeTable["psraw"] = 564; + opcodeTable["psrld"] = 565; + opcodeTable["psrldq"] = 566; + opcodeTable["psrlq"] = 567; + opcodeTable["psrlw"] = 568; + opcodeTable["psubb"] = 569; + opcodeTable["psubd"] = 570; + opcodeTable["psubq"] = 571; + opcodeTable["psubsb"] = 572; + opcodeTable["psubsw"] = 573; + opcodeTable["psubusb"] = 574; + opcodeTable["psubusw"] = 575; + opcodeTable["punpckhbw"] = 576; + opcodeTable["punpckhdq"] = 577; + opcodeTable["punpckhqdq"] = 578; + opcodeTable["punpckhwd"] = 579; + opcodeTable["punpcklbw"] = 580; + opcodeTable["punpckldq"] = 581; + opcodeTable["punpcklqdq"] = 582; + opcodeTable["punpcklwd"] = 583; + opcodeTable["pxor"] = 584; + opcodeTable["rcpps"] = 585; + opcodeTable["rcpss"] = 586; + opcodeTable["roundpd"] = 587; + opcodeTable["roundps"] = 588; + opcodeTable["roundsd"] = 589; + opcodeTable["roundss"] = 590; + opcodeTable["rsqrtps"] = 591; + opcodeTable["rsqrtss"] = 592; + opcodeTable["shufpd"] = 593; + opcodeTable["shufps"] = 594; + opcodeTable["sqrtpd"] = 595; + opcodeTable["sqrtps"] = 596; + opcodeTable["sqrtsd"] = 597; + opcodeTable["sqrtss"] = 598; + opcodeTable["subpd"] = 599; + opcodeTable["subps"] = 600; + opcodeTable["subsd"] = 601; + opcodeTable["subss"] = 602; + opcodeTable["ucomisd"] = 603; + opcodeTable["ucomiss"] = 604; + opcodeTable["unpckhpd"] = 605; + opcodeTable["unpckhps"] = 606; + opcodeTable["unpcklpd"] = 607; + opcodeTable["unpcklps"] = 608; + opcodeTable["xorpd"] = 609; + opcodeTable["xorps"] = 610; + opcodeTable["invept"] = 611; + opcodeTable["invvpid"] = 612; + opcodeTable["vmcall"] = 613; + opcodeTable["vmclear"] = 614; + opcodeTable["vmlaunch"] = 615; + opcodeTable["vmptrld"] = 616; + opcodeTable["vmptrst"] = 617; + opcodeTable["vmread"] = 618; + opcodeTable["vmresume"] = 619; + opcodeTable["vmwrite"] = 620; + opcodeTable["vmxoff"] = 621; + opcodeTable["vmxon"] = 622; prefixTable["a16"] = 0; prefixTable["a32"] = 1; prefixTable["lock"] = 2; @@ -24112,17 +24114,84 @@ x64Token x64Parser::tokenBranches6242[] = { {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6243, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6246(x64Operand &operand, int tokenPos) +Coding x64Parser::tokenCoding6247_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6247(x64Operand &operand, int tokenPos) { operand.operandCoding = 501; + operand.values[16] = tokenCoding6247_16; + operand.values[17] = tokenCoding6247_17; + operand.values[18] = tokenCoding6247_18; + operand.values[19] = tokenCoding6247_19; } +x64Token x64Parser::tokenBranches6246[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc6247, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches6245[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6246, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6246 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) +Coding x64Parser::tokenCoding6250_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6250(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 501; + operand.values[16] = tokenCoding6250_16; + operand.values[17] = tokenCoding6250_17; + operand.values[18] = tokenCoding6250_18; + operand.values[19] = tokenCoding6250_19; +} +x64Token x64Parser::tokenBranches6249[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc6250, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6248[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6249 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6252(x64Operand &operand, int tokenPos) { operand.operandCoding = 502; +} +x64Token x64Parser::tokenBranches6251[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6252, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6264(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 503; operand.values[27] = new Coding[2]; CleanupValues.push_back(operand.values[27]); operand.values[27]->type = Coding::number; @@ -24134,19 +24203,19 @@ void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) operand.values[27][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6257[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6258, }, +x64Token x64Parser::tokenBranches6263[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6264, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6256[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257 }, +x64Token x64Parser::tokenBranches6262[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6263 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6255[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256 }, +x64Token x64Parser::tokenBranches6261[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6262 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6261(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -24159,49 +24228,49 @@ void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6254[] = { - {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6255, x64Parser::tokenBranches6255 }, +x64Token x64Parser::tokenBranches6260[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6261, x64Parser::tokenBranches6261 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6253[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254 }, +x64Token x64Parser::tokenBranches6259[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6260 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_16[] = { +Coding x64Parser::tokenCoding6268_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_17[] = { +Coding x64Parser::tokenCoding6268_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_18[] = { +Coding x64Parser::tokenCoding6268_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&' }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_19[] = { +Coding x64Parser::tokenCoding6268_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>' }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6262(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6268(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6262_16; - operand.values[17] = tokenCoding6262_17; - operand.values[18] = tokenCoding6262_18; - operand.values[19] = tokenCoding6262_19; + operand.values[16] = tokenCoding6268_16; + operand.values[17] = tokenCoding6268_17; + operand.values[18] = tokenCoding6268_18; + operand.values[19] = tokenCoding6268_19; } -x64Token x64Parser::tokenBranches6261[] = { - {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6262, }, +x64Token x64Parser::tokenBranches6267[] = { + {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6268, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6260[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261 }, +x64Token x64Parser::tokenBranches6266[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6267 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6266(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -24214,11 +24283,11 @@ void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6259[] = { - {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6260, x64Parser::tokenBranches6260 }, +x64Token x64Parser::tokenBranches6265[] = { + {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6266, x64Parser::tokenBranches6266 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6281(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24231,19 +24300,19 @@ void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6274[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6275, }, +x64Token x64Parser::tokenBranches6280[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6281, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6273[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274 }, +x64Token x64Parser::tokenBranches6279[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6272[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273 }, +x64Token x64Parser::tokenBranches6278[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6279 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6285(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24256,19 +24325,19 @@ void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6278[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6279, }, +x64Token x64Parser::tokenBranches6284[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6285, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6277[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278 }, +x64Token x64Parser::tokenBranches6283[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6276[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277 }, +x64Token x64Parser::tokenBranches6282[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6283 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6289(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24281,19 +24350,19 @@ void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6282[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6283, }, +x64Token x64Parser::tokenBranches6288[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6289, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6281[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282 }, +x64Token x64Parser::tokenBranches6287[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6288 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6280[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281 }, +x64Token x64Parser::tokenBranches6286[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6287 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6293(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24306,19 +24375,19 @@ void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6286[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6287, }, +x64Token x64Parser::tokenBranches6292[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6293, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6285[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286 }, +x64Token x64Parser::tokenBranches6291[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6292 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6284[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285 }, +x64Token x64Parser::tokenBranches6290[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6291 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6297(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24331,19 +24400,19 @@ void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6290[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6291, }, +x64Token x64Parser::tokenBranches6296[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6297, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6289[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290 }, +x64Token x64Parser::tokenBranches6295[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6296 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6288[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289 }, +x64Token x64Parser::tokenBranches6294[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6295 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6301(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24356,19 +24425,19 @@ void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6294[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6295, }, +x64Token x64Parser::tokenBranches6300[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6301, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6293[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294 }, +x64Token x64Parser::tokenBranches6299[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6300 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6292[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293 }, +x64Token x64Parser::tokenBranches6298[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6299 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6305(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24381,19 +24450,19 @@ void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6298[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6299, }, +x64Token x64Parser::tokenBranches6304[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6305, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6297[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298 }, +x64Token x64Parser::tokenBranches6303[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6304 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6296[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297 }, +x64Token x64Parser::tokenBranches6302[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6303 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6309(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24406,19 +24475,19 @@ void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6302[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6303, }, +x64Token x64Parser::tokenBranches6308[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6309, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6301[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302 }, +x64Token x64Parser::tokenBranches6307[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6308 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6300[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301 }, +x64Token x64Parser::tokenBranches6306[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6307 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6313(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24431,60 +24500,60 @@ void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6306[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6307, }, +x64Token x64Parser::tokenBranches6312[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6313, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6305[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306 }, +x64Token x64Parser::tokenBranches6311[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6312 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_16[] = { +Coding x64Parser::tokenCoding6316_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6310_17[] = { +Coding x64Parser::tokenCoding6316_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6310_19[] = { +Coding x64Parser::tokenCoding6316_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6310(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6310_16; - operand.values[17] = tokenCoding6310_17; - operand.values[19] = tokenCoding6310_19; + operand.values[16] = tokenCoding6316_16; + operand.values[17] = tokenCoding6316_17; + operand.values[19] = tokenCoding6316_19; } -x64Token x64Parser::tokenBranches6309[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6310, }, +x64Token x64Parser::tokenBranches6315[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6316, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_16[] = { +Coding x64Parser::tokenCoding6318_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6312_17[] = { +Coding x64Parser::tokenCoding6318_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6312_19[] = { +Coding x64Parser::tokenCoding6318_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6312(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6318(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6312_16; - operand.values[17] = tokenCoding6312_17; - operand.values[19] = tokenCoding6312_19; + operand.values[16] = tokenCoding6318_16; + operand.values[17] = tokenCoding6318_17; + operand.values[19] = tokenCoding6318_19; } -x64Token x64Parser::tokenBranches6311[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6312, }, +x64Token x64Parser::tokenBranches6317[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6318, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6314(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24497,14 +24566,14 @@ void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6304[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305 }, - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6308, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, +x64Token x64Parser::tokenBranches6310[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6314, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6317 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24517,19 +24586,19 @@ void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6315[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6316, }, +x64Token x64Parser::tokenBranches6321[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6314[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, +x64Token x64Parser::tokenBranches6320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6321 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6313[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314 }, +x64Token x64Parser::tokenBranches6319[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6320 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24542,64 +24611,64 @@ void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6319[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6320, }, +x64Token x64Parser::tokenBranches6325[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6326, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6318[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319 }, +x64Token x64Parser::tokenBranches6324[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6317[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318 }, +x64Token x64Parser::tokenBranches6323[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6324 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_16[] = { +Coding x64Parser::tokenCoding6330_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6324_17[] = { +Coding x64Parser::tokenCoding6330_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6324_19[] = { +Coding x64Parser::tokenCoding6330_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6324(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6330(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6324_16; - operand.values[17] = tokenCoding6324_17; - operand.values[19] = tokenCoding6324_19; + operand.values[16] = tokenCoding6330_16; + operand.values[17] = tokenCoding6330_17; + operand.values[19] = tokenCoding6330_19; } -x64Token x64Parser::tokenBranches6323[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6324, }, +x64Token x64Parser::tokenBranches6329[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6330, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_16[] = { +Coding x64Parser::tokenCoding6332_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6326_17[] = { +Coding x64Parser::tokenCoding6332_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6326_19[] = { +Coding x64Parser::tokenCoding6332_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6332(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6326_16; - operand.values[17] = tokenCoding6326_17; - operand.values[19] = tokenCoding6326_19; + operand.values[16] = tokenCoding6332_16; + operand.values[17] = tokenCoding6332_17; + operand.values[19] = tokenCoding6332_19; } -x64Token x64Parser::tokenBranches6325[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6326, }, +x64Token x64Parser::tokenBranches6331[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6332, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6328(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24612,622 +24681,567 @@ void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6321[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, +x64Token x64Parser::tokenBranches6327[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6328, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6329 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6331 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6337_18[] = { +Coding x64Parser::tokenCoding6343_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6337_19[] = { +Coding x64Parser::tokenCoding6343_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6337(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6343(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6337_18; - operand.values[19] = tokenCoding6337_19; + operand.values[18] = tokenCoding6343_18; + operand.values[19] = tokenCoding6343_19; } -x64Token x64Parser::tokenBranches6336[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6337, }, +x64Token x64Parser::tokenBranches6342[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6343, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6339_18[] = { +Coding x64Parser::tokenCoding6345_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6339_19[] = { +Coding x64Parser::tokenCoding6345_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6339(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6345(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6339_18; - operand.values[19] = tokenCoding6339_19; + operand.values[18] = tokenCoding6345_18; + operand.values[19] = tokenCoding6345_19; } -x64Token x64Parser::tokenBranches6338[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6339, }, +x64Token x64Parser::tokenBranches6344[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6345, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_16[] = { +Coding x64Parser::tokenCoding6353_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_17[] = { +Coding x64Parser::tokenCoding6353_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_18[] = { +Coding x64Parser::tokenCoding6353_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_19[] = { +Coding x64Parser::tokenCoding6353_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6347(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6353(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6347_16; - operand.values[17] = tokenCoding6347_17; - operand.values[18] = tokenCoding6347_18; - operand.values[19] = tokenCoding6347_19; + operand.values[16] = tokenCoding6353_16; + operand.values[17] = tokenCoding6353_17; + operand.values[18] = tokenCoding6353_18; + operand.values[19] = tokenCoding6353_19; } -x64Token x64Parser::tokenBranches6346[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6347, }, +x64Token x64Parser::tokenBranches6352[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6353, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_16[] = { +Coding x64Parser::tokenCoding6355_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_17[] = { +Coding x64Parser::tokenCoding6355_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_18[] = { +Coding x64Parser::tokenCoding6355_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_19[] = { +Coding x64Parser::tokenCoding6355_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6349(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6355(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6349_16; - operand.values[17] = tokenCoding6349_17; - operand.values[18] = tokenCoding6349_18; - operand.values[19] = tokenCoding6349_19; + operand.values[16] = tokenCoding6355_16; + operand.values[17] = tokenCoding6355_17; + operand.values[18] = tokenCoding6355_18; + operand.values[19] = tokenCoding6355_19; } -x64Token x64Parser::tokenBranches6348[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6349, }, +x64Token x64Parser::tokenBranches6354[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6355, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_16[] = { +Coding x64Parser::tokenCoding6357_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_17[] = { +Coding x64Parser::tokenCoding6357_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_18[] = { +Coding x64Parser::tokenCoding6357_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_19[] = { +Coding x64Parser::tokenCoding6357_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6351(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6357(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6351_16; - operand.values[17] = tokenCoding6351_17; - operand.values[18] = tokenCoding6351_18; - operand.values[19] = tokenCoding6351_19; + operand.values[16] = tokenCoding6357_16; + operand.values[17] = tokenCoding6357_17; + operand.values[18] = tokenCoding6357_18; + operand.values[19] = tokenCoding6357_19; } -x64Token x64Parser::tokenBranches6350[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6351, }, +x64Token x64Parser::tokenBranches6356[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6357, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6345[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350 }, +x64Token x64Parser::tokenBranches6351[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6352 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6354 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6356 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_16[] = { +Coding x64Parser::tokenCoding6365_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_17[] = { +Coding x64Parser::tokenCoding6365_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_18[] = { +Coding x64Parser::tokenCoding6365_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_19[] = { +Coding x64Parser::tokenCoding6365_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6359(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6359_16; - operand.values[17] = tokenCoding6359_17; - operand.values[18] = tokenCoding6359_18; - operand.values[19] = tokenCoding6359_19; + operand.values[16] = tokenCoding6365_16; + operand.values[17] = tokenCoding6365_17; + operand.values[18] = tokenCoding6365_18; + operand.values[19] = tokenCoding6365_19; } -x64Token x64Parser::tokenBranches6358[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6359, }, +x64Token x64Parser::tokenBranches6364[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6365, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_16[] = { +Coding x64Parser::tokenCoding6367_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_17[] = { +Coding x64Parser::tokenCoding6367_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_18[] = { +Coding x64Parser::tokenCoding6367_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_19[] = { +Coding x64Parser::tokenCoding6367_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6361(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6361_16; - operand.values[17] = tokenCoding6361_17; - operand.values[18] = tokenCoding6361_18; - operand.values[19] = tokenCoding6361_19; + operand.values[16] = tokenCoding6367_16; + operand.values[17] = tokenCoding6367_17; + operand.values[18] = tokenCoding6367_18; + operand.values[19] = tokenCoding6367_19; } -x64Token x64Parser::tokenBranches6360[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6361, }, +x64Token x64Parser::tokenBranches6366[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6357[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360 }, +x64Token x64Parser::tokenBranches6363[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6364 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_16[] = { +Coding x64Parser::tokenCoding6373_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_17[] = { +Coding x64Parser::tokenCoding6373_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_18[] = { +Coding x64Parser::tokenCoding6373_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_19[] = { +Coding x64Parser::tokenCoding6373_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6373(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6367_16; - operand.values[17] = tokenCoding6367_17; - operand.values[18] = tokenCoding6367_18; - operand.values[19] = tokenCoding6367_19; + operand.values[16] = tokenCoding6373_16; + operand.values[17] = tokenCoding6373_17; + operand.values[18] = tokenCoding6373_18; + operand.values[19] = tokenCoding6373_19; } -x64Token x64Parser::tokenBranches6366[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, +x64Token x64Parser::tokenBranches6372[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6373, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_16[] = { +Coding x64Parser::tokenCoding6375_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_17[] = { +Coding x64Parser::tokenCoding6375_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_18[] = { +Coding x64Parser::tokenCoding6375_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_19[] = { +Coding x64Parser::tokenCoding6375_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6369(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6369_16; - operand.values[17] = tokenCoding6369_17; - operand.values[18] = tokenCoding6369_18; - operand.values[19] = tokenCoding6369_19; + operand.values[16] = tokenCoding6375_16; + operand.values[17] = tokenCoding6375_17; + operand.values[18] = tokenCoding6375_18; + operand.values[19] = tokenCoding6375_19; } -x64Token x64Parser::tokenBranches6368[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6369, }, +x64Token x64Parser::tokenBranches6374[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_16[] = { +Coding x64Parser::tokenCoding6377_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_17[] = { +Coding x64Parser::tokenCoding6377_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_18[] = { +Coding x64Parser::tokenCoding6377_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_19[] = { +Coding x64Parser::tokenCoding6377_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6371_16; - operand.values[17] = tokenCoding6371_17; - operand.values[18] = tokenCoding6371_18; - operand.values[19] = tokenCoding6371_19; + operand.values[16] = tokenCoding6377_16; + operand.values[17] = tokenCoding6377_17; + operand.values[18] = tokenCoding6377_18; + operand.values[19] = tokenCoding6377_19; } -x64Token x64Parser::tokenBranches6370[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6371, }, +x64Token x64Parser::tokenBranches6376[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6365_18[] = { +Coding x64Parser::tokenCoding6371_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6365_19[] = { +Coding x64Parser::tokenCoding6371_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6365_18; - operand.values[19] = tokenCoding6365_19; + operand.values[18] = tokenCoding6371_18; + operand.values[19] = tokenCoding6371_19; } -x64Token x64Parser::tokenBranches6364[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6365, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368 }, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370 }, +x64Token x64Parser::tokenBranches6370[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6371, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6372 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6374 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6376 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_16[] = { +Coding x64Parser::tokenCoding6381_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_17[] = { +Coding x64Parser::tokenCoding6381_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_18[] = { +Coding x64Parser::tokenCoding6381_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_19[] = { +Coding x64Parser::tokenCoding6381_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6381(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6375_16; - operand.values[17] = tokenCoding6375_17; - operand.values[18] = tokenCoding6375_18; - operand.values[19] = tokenCoding6375_19; + operand.values[16] = tokenCoding6381_16; + operand.values[17] = tokenCoding6381_17; + operand.values[18] = tokenCoding6381_18; + operand.values[19] = tokenCoding6381_19; } -x64Token x64Parser::tokenBranches6374[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, +x64Token x64Parser::tokenBranches6380[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6381, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6373[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374 }, +x64Token x64Parser::tokenBranches6379[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6380 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_16[] = { +Coding x64Parser::tokenCoding6383_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_17[] = { +Coding x64Parser::tokenCoding6383_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_18[] = { +Coding x64Parser::tokenCoding6383_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_19[] = { +Coding x64Parser::tokenCoding6383_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6383(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6377_16; - operand.values[17] = tokenCoding6377_17; - operand.values[18] = tokenCoding6377_18; - operand.values[19] = tokenCoding6377_19; + operand.values[16] = tokenCoding6383_16; + operand.values[17] = tokenCoding6383_17; + operand.values[18] = tokenCoding6383_18; + operand.values[19] = tokenCoding6383_19; } -x64Token x64Parser::tokenBranches6376[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, +x64Token x64Parser::tokenBranches6382[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6383, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_16[] = { +Coding x64Parser::tokenCoding6394_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_17[] = { +Coding x64Parser::tokenCoding6394_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_18[] = { +Coding x64Parser::tokenCoding6394_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_19[] = { +Coding x64Parser::tokenCoding6394_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6388(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6394(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6388_16; - operand.values[17] = tokenCoding6388_17; - operand.values[18] = tokenCoding6388_18; - operand.values[19] = tokenCoding6388_19; + operand.values[16] = tokenCoding6394_16; + operand.values[17] = tokenCoding6394_17; + operand.values[18] = tokenCoding6394_18; + operand.values[19] = tokenCoding6394_19; } -x64Token x64Parser::tokenBranches6387[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6388, }, +x64Token x64Parser::tokenBranches6393[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6394, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_16[] = { +Coding x64Parser::tokenCoding6401_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_17[] = { +Coding x64Parser::tokenCoding6401_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_18[] = { +Coding x64Parser::tokenCoding6401_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_19[] = { +Coding x64Parser::tokenCoding6401_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6395(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6401(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6395_16; - operand.values[17] = tokenCoding6395_17; - operand.values[18] = tokenCoding6395_18; - operand.values[19] = tokenCoding6395_19; + operand.values[16] = tokenCoding6401_16; + operand.values[17] = tokenCoding6401_17; + operand.values[18] = tokenCoding6401_18; + operand.values[19] = tokenCoding6401_19; } -x64Token x64Parser::tokenBranches6394[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6395, }, +x64Token x64Parser::tokenBranches6400[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6401, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_16[] = { +Coding x64Parser::tokenCoding6403_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_17[] = { +Coding x64Parser::tokenCoding6403_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_18[] = { +Coding x64Parser::tokenCoding6403_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_19[] = { +Coding x64Parser::tokenCoding6403_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6397(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6403(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6397_16; - operand.values[17] = tokenCoding6397_17; - operand.values[18] = tokenCoding6397_18; - operand.values[19] = tokenCoding6397_19; + operand.values[16] = tokenCoding6403_16; + operand.values[17] = tokenCoding6403_17; + operand.values[18] = tokenCoding6403_18; + operand.values[19] = tokenCoding6403_19; } -x64Token x64Parser::tokenBranches6396[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6397, }, +x64Token x64Parser::tokenBranches6402[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6403, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_16[] = { +Coding x64Parser::tokenCoding6412_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_17[] = { +Coding x64Parser::tokenCoding6412_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_18[] = { +Coding x64Parser::tokenCoding6412_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_19[] = { +Coding x64Parser::tokenCoding6412_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6406(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6412(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6406_16; - operand.values[17] = tokenCoding6406_17; - operand.values[18] = tokenCoding6406_18; - operand.values[19] = tokenCoding6406_19; + operand.values[16] = tokenCoding6412_16; + operand.values[17] = tokenCoding6412_17; + operand.values[18] = tokenCoding6412_18; + operand.values[19] = tokenCoding6412_19; } -x64Token x64Parser::tokenBranches6405[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6406, }, +x64Token x64Parser::tokenBranches6411[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6412, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_16[] = { +Coding x64Parser::tokenCoding6414_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_17[] = { +Coding x64Parser::tokenCoding6414_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_18[] = { +Coding x64Parser::tokenCoding6414_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_19[] = { +Coding x64Parser::tokenCoding6414_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6408(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6408_16; - operand.values[17] = tokenCoding6408_17; - operand.values[18] = tokenCoding6408_18; - operand.values[19] = tokenCoding6408_19; + operand.values[16] = tokenCoding6414_16; + operand.values[17] = tokenCoding6414_17; + operand.values[18] = tokenCoding6414_18; + operand.values[19] = tokenCoding6414_19; } -x64Token x64Parser::tokenBranches6407[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6408, }, +x64Token x64Parser::tokenBranches6413[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6414, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6404_18[] = { +Coding x64Parser::tokenCoding6410_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6404_19[] = { +Coding x64Parser::tokenCoding6410_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6404(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6410(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6404_18; - operand.values[19] = tokenCoding6404_19; + operand.values[18] = tokenCoding6410_18; + operand.values[19] = tokenCoding6410_19; } -x64Token x64Parser::tokenBranches6403[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6404, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407 }, +x64Token x64Parser::tokenBranches6409[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6410, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6411 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6413 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_16[] = { +Coding x64Parser::tokenCoding6417_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_17[] = { +Coding x64Parser::tokenCoding6417_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_18[] = { +Coding x64Parser::tokenCoding6417_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_19[] = { +Coding x64Parser::tokenCoding6417_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6411(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6417(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6411_16; - operand.values[17] = tokenCoding6411_17; - operand.values[18] = tokenCoding6411_18; - operand.values[19] = tokenCoding6411_19; + operand.values[16] = tokenCoding6417_16; + operand.values[17] = tokenCoding6417_17; + operand.values[18] = tokenCoding6417_18; + operand.values[19] = tokenCoding6417_19; } -x64Token x64Parser::tokenBranches6410[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6411, }, +x64Token x64Parser::tokenBranches6416[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6417, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6409[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410 }, +x64Token x64Parser::tokenBranches6415[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6416 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_16[] = { +Coding x64Parser::tokenCoding6420_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_17[] = { +Coding x64Parser::tokenCoding6420_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_18[] = { +Coding x64Parser::tokenCoding6420_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6414_16; - operand.values[17] = tokenCoding6414_17; - operand.values[18] = tokenCoding6414_18; - operand.values[19] = tokenCoding6414_19; -} -x64Token x64Parser::tokenBranches6413[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6414, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6412[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding6416_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding6420_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6416(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6416_16; - operand.values[17] = tokenCoding6416_17; - operand.values[18] = tokenCoding6416_18; - operand.values[19] = tokenCoding6416_19; + operand.values[16] = tokenCoding6420_16; + operand.values[17] = tokenCoding6420_17; + operand.values[18] = tokenCoding6420_18; + operand.values[19] = tokenCoding6420_19; } -x64Token x64Parser::tokenBranches6415[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6416, }, +x64Token x64Parser::tokenBranches6419[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6420, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc6418(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6418_16; - operand.values[17] = tokenCoding6418_17; - operand.values[18] = tokenCoding6418_18; - operand.values[19] = tokenCoding6418_19; -} -x64Token x64Parser::tokenBranches6417[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6418, }, +x64Token x64Parser::tokenBranches6418[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6419 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding6422_16[] = { @@ -25239,11 +25253,12 @@ Coding x64Parser::tokenCoding6422_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6422_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6422_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) @@ -25254,7 +25269,7 @@ void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) operand.values[19] = tokenCoding6422_19; } x64Token x64Parser::tokenBranches6421[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6422, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6422, }, {x64Token::EOT } }; Coding x64Parser::tokenCoding6424_16[] = { @@ -25266,11 +25281,11 @@ Coding x64Parser::tokenCoding6424_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6424_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6424_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) @@ -25281,130 +25296,184 @@ void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) operand.values[19] = tokenCoding6424_19; } x64Token x64Parser::tokenBranches6423[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6424, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6424, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_16[] = { +Coding x64Parser::tokenCoding6428_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_17[] = { +Coding x64Parser::tokenCoding6428_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_18[] = { +Coding x64Parser::tokenCoding6428_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6428_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6428(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6428_16; + operand.values[17] = tokenCoding6428_17; + operand.values[18] = tokenCoding6428_18; + operand.values[19] = tokenCoding6428_19; +} +x64Token x64Parser::tokenBranches6427[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6428, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6430_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6430_16; + operand.values[17] = tokenCoding6430_17; + operand.values[18] = tokenCoding6430_18; + operand.values[19] = tokenCoding6430_19; +} +x64Token x64Parser::tokenBranches6429[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6432_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6432_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6432_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_19[] = { +Coding x64Parser::tokenCoding6432_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6432(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6426_16; - operand.values[17] = tokenCoding6426_17; - operand.values[18] = tokenCoding6426_18; - operand.values[19] = tokenCoding6426_19; + operand.values[16] = tokenCoding6432_16; + operand.values[17] = tokenCoding6432_17; + operand.values[18] = tokenCoding6432_18; + operand.values[19] = tokenCoding6432_19; } -x64Token x64Parser::tokenBranches6425[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6426, }, +x64Token x64Parser::tokenBranches6431[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6432, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6420_18[] = { +Coding x64Parser::tokenCoding6426_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6420_19[] = { +Coding x64Parser::tokenCoding6426_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6420_18; - operand.values[19] = tokenCoding6420_19; + operand.values[18] = tokenCoding6426_18; + operand.values[19] = tokenCoding6426_19; } -x64Token x64Parser::tokenBranches6419[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6420, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423 }, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425 }, +x64Token x64Parser::tokenBranches6425[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6426, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6427 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6429 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6431 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_16[] = { +Coding x64Parser::tokenCoding6435_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_17[] = { +Coding x64Parser::tokenCoding6435_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_18[] = { +Coding x64Parser::tokenCoding6435_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_19[] = { +Coding x64Parser::tokenCoding6435_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6429(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6435(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6429_16; - operand.values[17] = tokenCoding6429_17; - operand.values[18] = tokenCoding6429_18; - operand.values[19] = tokenCoding6429_19; + operand.values[16] = tokenCoding6435_16; + operand.values[17] = tokenCoding6435_17; + operand.values[18] = tokenCoding6435_18; + operand.values[19] = tokenCoding6435_19; } -x64Token x64Parser::tokenBranches6428[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6429, }, +x64Token x64Parser::tokenBranches6434[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6435, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6436(x64Operand &operand, int tokenPos) { - operand.operandCoding = 503; + operand.operandCoding = 504; } -x64Token x64Parser::tokenBranches6427[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428 }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, +x64Token x64Parser::tokenBranches6433[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6434 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6436, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_16[] = { +Coding x64Parser::tokenCoding6439_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_17[] = { +Coding x64Parser::tokenCoding6439_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_18[] = { +Coding x64Parser::tokenCoding6439_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_19[] = { +Coding x64Parser::tokenCoding6439_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6433(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6439(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6433_16; - operand.values[17] = tokenCoding6433_17; - operand.values[18] = tokenCoding6433_18; - operand.values[19] = tokenCoding6433_19; + operand.values[16] = tokenCoding6439_16; + operand.values[17] = tokenCoding6439_17; + operand.values[18] = tokenCoding6439_18; + operand.values[19] = tokenCoding6439_19; } -x64Token x64Parser::tokenBranches6432[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6433, }, +x64Token x64Parser::tokenBranches6438[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6439, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6434(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6440(x64Operand &operand, int tokenPos) { - operand.operandCoding = 504; + operand.operandCoding = 505; } -x64Token x64Parser::tokenBranches6431[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432 }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6434, }, +x64Token x64Parser::tokenBranches6437[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6438 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6440, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6450(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25417,19 +25486,19 @@ void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6443[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6444, }, +x64Token x64Parser::tokenBranches6449[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6450, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6442[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443 }, +x64Token x64Parser::tokenBranches6448[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6449 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6441[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442 }, +x64Token x64Parser::tokenBranches6447[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6448 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6454(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25442,19 +25511,19 @@ void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6447[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6448, }, +x64Token x64Parser::tokenBranches6453[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6454, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6446[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447 }, +x64Token x64Parser::tokenBranches6452[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6453 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6445[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446 }, +x64Token x64Parser::tokenBranches6451[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6452 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25467,19 +25536,19 @@ void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6456[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6457, }, +x64Token x64Parser::tokenBranches6462[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6463, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6455[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456 }, +x64Token x64Parser::tokenBranches6461[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6462 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6454[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455 }, +x64Token x64Parser::tokenBranches6460[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6461 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6467(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25492,77 +25561,77 @@ void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6460[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6461, }, +x64Token x64Parser::tokenBranches6466[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6467, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6459[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460 }, +x64Token x64Parser::tokenBranches6465[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6466 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6458[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459 }, +x64Token x64Parser::tokenBranches6464[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6465 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_16[] = { +Coding x64Parser::tokenCoding6469_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_17[] = { +Coding x64Parser::tokenCoding6469_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_18[] = { +Coding x64Parser::tokenCoding6469_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_19[] = { +Coding x64Parser::tokenCoding6469_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6469(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6463_16; - operand.values[17] = tokenCoding6463_17; - operand.values[18] = tokenCoding6463_18; - operand.values[19] = tokenCoding6463_19; + operand.values[16] = tokenCoding6469_16; + operand.values[17] = tokenCoding6469_17; + operand.values[18] = tokenCoding6469_18; + operand.values[19] = tokenCoding6469_19; } -x64Token x64Parser::tokenBranches6462[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6463, }, +x64Token x64Parser::tokenBranches6468[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6469, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_16[] = { +Coding x64Parser::tokenCoding6471_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_17[] = { +Coding x64Parser::tokenCoding6471_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_18[] = { +Coding x64Parser::tokenCoding6471_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_19[] = { +Coding x64Parser::tokenCoding6471_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6465(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6471(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6465_16; - operand.values[17] = tokenCoding6465_17; - operand.values[18] = tokenCoding6465_18; - operand.values[19] = tokenCoding6465_19; + operand.values[16] = tokenCoding6471_16; + operand.values[17] = tokenCoding6471_17; + operand.values[18] = tokenCoding6471_18; + operand.values[19] = tokenCoding6471_19; } -x64Token x64Parser::tokenBranches6464[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6465, }, +x64Token x64Parser::tokenBranches6470[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6471, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6482(x64Operand &operand, int tokenPos) { - operand.operandCoding = 505; + operand.operandCoding = 506; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25574,30 +25643,30 @@ void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6475[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6476, }, +x64Token x64Parser::tokenBranches6481[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6482, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_16[] = { +Coding x64Parser::tokenCoding6509_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_17[] = { +Coding x64Parser::tokenCoding6509_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_18[] = { +Coding x64Parser::tokenCoding6509_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_19[] = { +Coding x64Parser::tokenCoding6509_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 4 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25608,35 +25677,35 @@ void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6503_16; - operand.values[17] = tokenCoding6503_17; - operand.values[18] = tokenCoding6503_18; - operand.values[19] = tokenCoding6503_19; + operand.values[16] = tokenCoding6509_16; + operand.values[17] = tokenCoding6509_17; + operand.values[18] = tokenCoding6509_18; + operand.values[19] = tokenCoding6509_19; } -x64Token x64Parser::tokenBranches6502[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6503, }, +x64Token x64Parser::tokenBranches6508[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6509, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_16[] = { +Coding x64Parser::tokenCoding6515_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_17[] = { +Coding x64Parser::tokenCoding6515_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_18[] = { +Coding x64Parser::tokenCoding6515_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_19[] = { +Coding x64Parser::tokenCoding6515_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6515(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25647,23 +25716,23 @@ void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6509_16; - operand.values[17] = tokenCoding6509_17; - operand.values[18] = tokenCoding6509_18; - operand.values[19] = tokenCoding6509_19; + operand.values[16] = tokenCoding6515_16; + operand.values[17] = tokenCoding6515_17; + operand.values[18] = tokenCoding6515_18; + operand.values[19] = tokenCoding6515_19; } -x64Token x64Parser::tokenBranches6501[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502 }, - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6509, }, +x64Token x64Parser::tokenBranches6507[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6508 }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6515, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6500[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501 }, +x64Token x64Parser::tokenBranches6506[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6507 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6486(x64Operand &operand, int tokenPos) { - operand.operandCoding = 506; + operand.operandCoding = 507; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25675,48 +25744,48 @@ void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6500_16[] = { +Coding x64Parser::tokenCoding6506_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_17[] = { +Coding x64Parser::tokenCoding6506_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_18[] = { +Coding x64Parser::tokenCoding6506_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_19[] = { +Coding x64Parser::tokenCoding6506_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6500(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6506(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6500_16; - operand.values[17] = tokenCoding6500_17; - operand.values[18] = tokenCoding6500_18; - operand.values[19] = tokenCoding6500_19; + operand.values[16] = tokenCoding6506_16; + operand.values[17] = tokenCoding6506_17; + operand.values[18] = tokenCoding6506_18; + operand.values[19] = tokenCoding6506_19; } -x64Token x64Parser::tokenBranches6479[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6480, }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6500, x64Parser::tokenBranches6500 }, +x64Token x64Parser::tokenBranches6485[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6486, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6506, x64Parser::tokenBranches6506 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6474[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479 }, +x64Token x64Parser::tokenBranches6480[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6481 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6485 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6473[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474 }, +x64Token x64Parser::tokenBranches6479[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6480 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6490(x64Operand &operand, int tokenPos) { - operand.operandCoding = 507; + operand.operandCoding = 508; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25728,30 +25797,30 @@ void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6483[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6484, }, +x64Token x64Parser::tokenBranches6489[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6490, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6520_16[] = { +Coding x64Parser::tokenCoding6526_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_17[] = { +Coding x64Parser::tokenCoding6526_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_18[] = { +Coding x64Parser::tokenCoding6526_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_19[] = { +Coding x64Parser::tokenCoding6526_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 5 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25762,35 +25831,35 @@ void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6520_16; - operand.values[17] = tokenCoding6520_17; - operand.values[18] = tokenCoding6520_18; - operand.values[19] = tokenCoding6520_19; + operand.values[16] = tokenCoding6526_16; + operand.values[17] = tokenCoding6526_17; + operand.values[18] = tokenCoding6526_18; + operand.values[19] = tokenCoding6526_19; } -x64Token x64Parser::tokenBranches6519[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6520, }, +x64Token x64Parser::tokenBranches6525[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6526, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6526_16[] = { +Coding x64Parser::tokenCoding6532_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_17[] = { +Coding x64Parser::tokenCoding6532_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_18[] = { +Coding x64Parser::tokenCoding6532_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_19[] = { +Coding x64Parser::tokenCoding6532_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6532(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25801,23 +25870,23 @@ void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6526_16; - operand.values[17] = tokenCoding6526_17; - operand.values[18] = tokenCoding6526_18; - operand.values[19] = tokenCoding6526_19; + operand.values[16] = tokenCoding6532_16; + operand.values[17] = tokenCoding6532_17; + operand.values[18] = tokenCoding6532_18; + operand.values[19] = tokenCoding6532_19; } -x64Token x64Parser::tokenBranches6518[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519 }, - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6526, }, +x64Token x64Parser::tokenBranches6524[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6525 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6532, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6517[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518 }, +x64Token x64Parser::tokenBranches6523[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6524 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6494(x64Operand &operand, int tokenPos) { - operand.operandCoding = 508; + operand.operandCoding = 509; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25829,48 +25898,48 @@ void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6517_16[] = { +Coding x64Parser::tokenCoding6523_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_17[] = { +Coding x64Parser::tokenCoding6523_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_18[] = { +Coding x64Parser::tokenCoding6523_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_19[] = { +Coding x64Parser::tokenCoding6523_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6517(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6523(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6517_16; - operand.values[17] = tokenCoding6517_17; - operand.values[18] = tokenCoding6517_18; - operand.values[19] = tokenCoding6517_19; + operand.values[16] = tokenCoding6523_16; + operand.values[17] = tokenCoding6523_17; + operand.values[18] = tokenCoding6523_18; + operand.values[19] = tokenCoding6523_19; } -x64Token x64Parser::tokenBranches6487[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6488, }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6517, x64Parser::tokenBranches6517 }, +x64Token x64Parser::tokenBranches6493[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6494, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6523, x64Parser::tokenBranches6523 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6482[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487 }, +x64Token x64Parser::tokenBranches6488[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6489 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6493 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6481[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482 }, +x64Token x64Parser::tokenBranches6487[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6488 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6498(x64Operand &operand, int tokenPos) { - operand.operandCoding = 509; + operand.operandCoding = 510; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25882,30 +25951,30 @@ void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6491[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6492, }, +x64Token x64Parser::tokenBranches6497[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6498, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6537_16[] = { +Coding x64Parser::tokenCoding6543_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_17[] = { +Coding x64Parser::tokenCoding6543_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_18[] = { +Coding x64Parser::tokenCoding6543_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_19[] = { +Coding x64Parser::tokenCoding6543_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 6 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25916,35 +25985,35 @@ void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6537_16; - operand.values[17] = tokenCoding6537_17; - operand.values[18] = tokenCoding6537_18; - operand.values[19] = tokenCoding6537_19; + operand.values[16] = tokenCoding6543_16; + operand.values[17] = tokenCoding6543_17; + operand.values[18] = tokenCoding6543_18; + operand.values[19] = tokenCoding6543_19; } -x64Token x64Parser::tokenBranches6536[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6537, }, +x64Token x64Parser::tokenBranches6542[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6543, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_16[] = { +Coding x64Parser::tokenCoding6549_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_17[] = { +Coding x64Parser::tokenCoding6549_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_18[] = { +Coding x64Parser::tokenCoding6549_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_19[] = { +Coding x64Parser::tokenCoding6549_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25955,23 +26024,23 @@ void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6543_16; - operand.values[17] = tokenCoding6543_17; - operand.values[18] = tokenCoding6543_18; - operand.values[19] = tokenCoding6543_19; + operand.values[16] = tokenCoding6549_16; + operand.values[17] = tokenCoding6549_17; + operand.values[18] = tokenCoding6549_18; + operand.values[19] = tokenCoding6549_19; } -x64Token x64Parser::tokenBranches6535[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536 }, - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6543, }, +x64Token x64Parser::tokenBranches6541[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6542 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6549, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6534[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535 }, +x64Token x64Parser::tokenBranches6540[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6541 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6502(x64Operand &operand, int tokenPos) { - operand.operandCoding = 510; + operand.operandCoding = 511; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25983,157 +26052,157 @@ void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6534_16[] = { +Coding x64Parser::tokenCoding6540_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_17[] = { +Coding x64Parser::tokenCoding6540_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_18[] = { +Coding x64Parser::tokenCoding6540_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_19[] = { +Coding x64Parser::tokenCoding6540_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6534(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6540(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6534_16; - operand.values[17] = tokenCoding6534_17; - operand.values[18] = tokenCoding6534_18; - operand.values[19] = tokenCoding6534_19; + operand.values[16] = tokenCoding6540_16; + operand.values[17] = tokenCoding6540_17; + operand.values[18] = tokenCoding6540_18; + operand.values[19] = tokenCoding6540_19; } -x64Token x64Parser::tokenBranches6495[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6496, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6534, x64Parser::tokenBranches6534 }, +x64Token x64Parser::tokenBranches6501[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6502, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6540, x64Parser::tokenBranches6540 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6490[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495 }, +x64Token x64Parser::tokenBranches6496[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6497 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6501 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6489[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490 }, +x64Token x64Parser::tokenBranches6495[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6496 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_16[] = { +Coding x64Parser::tokenCoding6555_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_17[] = { +Coding x64Parser::tokenCoding6555_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_18[] = { +Coding x64Parser::tokenCoding6555_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_19[] = { +Coding x64Parser::tokenCoding6555_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6549_16; - operand.values[17] = tokenCoding6549_17; - operand.values[18] = tokenCoding6549_18; - operand.values[19] = tokenCoding6549_19; + operand.values[16] = tokenCoding6555_16; + operand.values[17] = tokenCoding6555_17; + operand.values[18] = tokenCoding6555_18; + operand.values[19] = tokenCoding6555_19; } -x64Token x64Parser::tokenBranches6548[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6549, }, +x64Token x64Parser::tokenBranches6554[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6551_16[] = { +Coding x64Parser::tokenCoding6557_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_17[] = { +Coding x64Parser::tokenCoding6557_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_18[] = { +Coding x64Parser::tokenCoding6557_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_19[] = { +Coding x64Parser::tokenCoding6557_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6551(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6557(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6551_16; - operand.values[17] = tokenCoding6551_17; - operand.values[18] = tokenCoding6551_18; - operand.values[19] = tokenCoding6551_19; + operand.values[16] = tokenCoding6557_16; + operand.values[17] = tokenCoding6557_17; + operand.values[18] = tokenCoding6557_18; + operand.values[19] = tokenCoding6557_19; } -x64Token x64Parser::tokenBranches6550[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6551, }, +x64Token x64Parser::tokenBranches6556[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6557, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6553_16[] = { +Coding x64Parser::tokenCoding6559_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_17[] = { +Coding x64Parser::tokenCoding6559_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_18[] = { +Coding x64Parser::tokenCoding6559_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_19[] = { +Coding x64Parser::tokenCoding6559_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6553(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6559(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6553_16; - operand.values[17] = tokenCoding6553_17; - operand.values[18] = tokenCoding6553_18; - operand.values[19] = tokenCoding6553_19; + operand.values[16] = tokenCoding6559_16; + operand.values[17] = tokenCoding6559_17; + operand.values[18] = tokenCoding6559_18; + operand.values[19] = tokenCoding6559_19; } -x64Token x64Parser::tokenBranches6552[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6553, }, +x64Token x64Parser::tokenBranches6558[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6559, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6555_16[] = { +Coding x64Parser::tokenCoding6561_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_17[] = { +Coding x64Parser::tokenCoding6561_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_18[] = { +Coding x64Parser::tokenCoding6561_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_19[] = { +Coding x64Parser::tokenCoding6561_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6561(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6555_16; - operand.values[17] = tokenCoding6555_17; - operand.values[18] = tokenCoding6555_18; - operand.values[19] = tokenCoding6555_19; + operand.values[16] = tokenCoding6561_16; + operand.values[17] = tokenCoding6561_17; + operand.values[18] = tokenCoding6561_18; + operand.values[19] = tokenCoding6561_19; } -x64Token x64Parser::tokenBranches6554[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, +x64Token x64Parser::tokenBranches6560[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6561, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6479(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26145,7 +26214,7 @@ void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6487(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26157,7 +26226,7 @@ void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6495(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26169,19 +26238,19 @@ void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6472[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6473, x64Parser::tokenBranches6473 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6481, x64Parser::tokenBranches6481 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6489, x64Parser::tokenBranches6489 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, +x64Token x64Parser::tokenBranches6478[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6479, x64Parser::tokenBranches6479 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6487, x64Parser::tokenBranches6487 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6495, x64Parser::tokenBranches6495 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6556 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6560 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6566(x64Operand &operand, int tokenPos) { - operand.operandCoding = 514; + operand.operandCoding = 515; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26193,26 +26262,26 @@ void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6559[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6560, }, +x64Token x64Parser::tokenBranches6565[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6566, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6575(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) { - operand.operandCoding = 518; + operand.operandCoding = 519; } -x64Token x64Parser::tokenBranches6558[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6575, }, +x64Token x64Parser::tokenBranches6564[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6565 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6557[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, +x64Token x64Parser::tokenBranches6563[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6564 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6570(x64Operand &operand, int tokenPos) { - operand.operandCoding = 515; + operand.operandCoding = 516; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26224,26 +26293,26 @@ void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6563[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6564, }, +x64Token x64Parser::tokenBranches6569[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6570, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) { - operand.operandCoding = 519; + operand.operandCoding = 520; } -x64Token x64Parser::tokenBranches6562[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6578, }, +x64Token x64Parser::tokenBranches6568[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6569 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6561[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562 }, +x64Token x64Parser::tokenBranches6567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6568 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6574(x64Operand &operand, int tokenPos) { - operand.operandCoding = 516; + operand.operandCoding = 517; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26255,26 +26324,26 @@ void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6567[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6568, }, +x64Token x64Parser::tokenBranches6573[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6574, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6587(x64Operand &operand, int tokenPos) { - operand.operandCoding = 520; + operand.operandCoding = 521; } -x64Token x64Parser::tokenBranches6566[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, +x64Token x64Parser::tokenBranches6572[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6573 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6587, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6565[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566 }, +x64Token x64Parser::tokenBranches6571[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6572 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) { - operand.operandCoding = 517; + operand.operandCoding = 518; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26286,150 +26355,150 @@ void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6571[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6572, }, +x64Token x64Parser::tokenBranches6577[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6578, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6590(x64Operand &operand, int tokenPos) { - operand.operandCoding = 521; + operand.operandCoding = 522; } -x64Token x64Parser::tokenBranches6570[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, +x64Token x64Parser::tokenBranches6576[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6577 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6590, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6569[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570 }, +x64Token x64Parser::tokenBranches6575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6576 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6556[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569 }, +x64Token x64Parser::tokenBranches6562[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6563 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6567 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6571 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6575 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6599(x64Operand &operand, int tokenPos) { - operand.operandCoding = 522; + operand.operandCoding = 523; } -x64Token x64Parser::tokenBranches6592[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6593, }, +x64Token x64Parser::tokenBranches6598[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6599, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6591[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, +x64Token x64Parser::tokenBranches6597[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6590[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591 }, +x64Token x64Parser::tokenBranches6596[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6609(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6615(x64Operand &operand, int tokenPos) { - operand.operandCoding = 524; + operand.operandCoding = 525; } -x64Token x64Parser::tokenBranches6608[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6609, }, +x64Token x64Parser::tokenBranches6614[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6615, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6607[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608 }, +x64Token x64Parser::tokenBranches6613[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6606[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607 }, +x64Token x64Parser::tokenBranches6612[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6613 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6589[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, +x64Token x64Parser::tokenBranches6595[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6596 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6612 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6588[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589 }, +x64Token x64Parser::tokenBranches6594[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6587[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588 }, +x64Token x64Parser::tokenBranches6593[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6594 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6601(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6607(x64Operand &operand, int tokenPos) { - operand.operandCoding = 523; + operand.operandCoding = 524; } -x64Token x64Parser::tokenBranches6600[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6601, }, +x64Token x64Parser::tokenBranches6606[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6607, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6599[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600 }, +x64Token x64Parser::tokenBranches6605[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6598[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599 }, +x64Token x64Parser::tokenBranches6604[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6605 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6617(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) { - operand.operandCoding = 525; + operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches6616[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6617, }, +x64Token x64Parser::tokenBranches6622[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6615[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616 }, +x64Token x64Parser::tokenBranches6621[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6614[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615 }, +x64Token x64Parser::tokenBranches6620[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6631(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6637(x64Operand &operand, int tokenPos) { - operand.operandCoding = 527; + operand.operandCoding = 528; } -x64Token x64Parser::tokenBranches6630[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6631, }, +x64Token x64Parser::tokenBranches6636[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6637, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6629[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630 }, +x64Token x64Parser::tokenBranches6635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6628[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629 }, +x64Token x64Parser::tokenBranches6634[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6597[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, +x64Token x64Parser::tokenBranches6603[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6604 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6596[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, +x64Token x64Parser::tokenBranches6602[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6603 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6629(x64Operand &operand, int tokenPos) { - operand.operandCoding = 526; + operand.operandCoding = 527; } -x64Token x64Parser::tokenBranches6622[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, +x64Token x64Parser::tokenBranches6628[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6629, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6621[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, +x64Token x64Parser::tokenBranches6627[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6620[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, +x64Token x64Parser::tokenBranches6626[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6627 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6602(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26441,136 +26510,136 @@ void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6595[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6596, x64Parser::tokenBranches6596 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, +x64Token x64Parser::tokenBranches6601[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6602, x64Parser::tokenBranches6602 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6626 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6586[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, +x64Token x64Parser::tokenBranches6592[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6593 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6601 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6639(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6645(x64Operand &operand, int tokenPos) { - operand.operandCoding = 528; + operand.operandCoding = 529; } -x64Token x64Parser::tokenBranches6638[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6639, }, +x64Token x64Parser::tokenBranches6644[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6645, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6637[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, +x64Token x64Parser::tokenBranches6643[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6636[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637 }, +x64Token x64Parser::tokenBranches6642[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6655(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6661(x64Operand &operand, int tokenPos) { - operand.operandCoding = 530; + operand.operandCoding = 531; } -x64Token x64Parser::tokenBranches6654[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6655, }, +x64Token x64Parser::tokenBranches6660[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6661, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6653[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654 }, +x64Token x64Parser::tokenBranches6659[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6652[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653 }, +x64Token x64Parser::tokenBranches6658[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6659 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6635[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, +x64Token x64Parser::tokenBranches6641[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6642 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6658 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6634[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, +x64Token x64Parser::tokenBranches6640[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6633[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, +x64Token x64Parser::tokenBranches6639[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6640 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6647(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6653(x64Operand &operand, int tokenPos) { - operand.operandCoding = 529; + operand.operandCoding = 530; } -x64Token x64Parser::tokenBranches6646[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6647, }, +x64Token x64Parser::tokenBranches6652[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6653, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6645[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646 }, +x64Token x64Parser::tokenBranches6651[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6644[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645 }, +x64Token x64Parser::tokenBranches6650[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6651 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6663(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) { - operand.operandCoding = 531; + operand.operandCoding = 532; } -x64Token x64Parser::tokenBranches6662[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6663, }, +x64Token x64Parser::tokenBranches6668[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6661[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662 }, +x64Token x64Parser::tokenBranches6667[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6660[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661 }, +x64Token x64Parser::tokenBranches6666[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6677(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6683(x64Operand &operand, int tokenPos) { - operand.operandCoding = 533; + operand.operandCoding = 534; } -x64Token x64Parser::tokenBranches6676[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6677, }, +x64Token x64Parser::tokenBranches6682[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6683, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6675[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676 }, +x64Token x64Parser::tokenBranches6681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6674[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675 }, +x64Token x64Parser::tokenBranches6680[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6643[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, +x64Token x64Parser::tokenBranches6649[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6650 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6642[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, +x64Token x64Parser::tokenBranches6648[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6649 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6675(x64Operand &operand, int tokenPos) { - operand.operandCoding = 532; + operand.operandCoding = 533; } -x64Token x64Parser::tokenBranches6668[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, +x64Token x64Parser::tokenBranches6674[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6675, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6667[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, +x64Token x64Parser::tokenBranches6673[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6666[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, +x64Token x64Parser::tokenBranches6672[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6673 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6648(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26582,136 +26651,136 @@ void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6641[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6642, x64Parser::tokenBranches6642 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, +x64Token x64Parser::tokenBranches6647[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6648, x64Parser::tokenBranches6648 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6672 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6632[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, +x64Token x64Parser::tokenBranches6638[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6639 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6647 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6685(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6691(x64Operand &operand, int tokenPos) { - operand.operandCoding = 534; + operand.operandCoding = 535; } -x64Token x64Parser::tokenBranches6684[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6685, }, +x64Token x64Parser::tokenBranches6690[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6691, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6683[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, +x64Token x64Parser::tokenBranches6689[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6682[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683 }, +x64Token x64Parser::tokenBranches6688[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6701(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6707(x64Operand &operand, int tokenPos) { - operand.operandCoding = 536; + operand.operandCoding = 537; } -x64Token x64Parser::tokenBranches6700[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6701, }, +x64Token x64Parser::tokenBranches6706[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6707, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6699[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700 }, +x64Token x64Parser::tokenBranches6705[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6698[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699 }, +x64Token x64Parser::tokenBranches6704[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6705 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6681[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, +x64Token x64Parser::tokenBranches6687[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6688 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6704 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6680[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, +x64Token x64Parser::tokenBranches6686[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6679[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, +x64Token x64Parser::tokenBranches6685[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6686 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6693(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6699(x64Operand &operand, int tokenPos) { - operand.operandCoding = 535; + operand.operandCoding = 536; } -x64Token x64Parser::tokenBranches6692[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6693, }, +x64Token x64Parser::tokenBranches6698[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6699, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6691[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692 }, +x64Token x64Parser::tokenBranches6697[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6690[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691 }, +x64Token x64Parser::tokenBranches6696[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6697 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6709(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) { - operand.operandCoding = 537; + operand.operandCoding = 538; } -x64Token x64Parser::tokenBranches6708[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6709, }, +x64Token x64Parser::tokenBranches6714[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6707[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708 }, +x64Token x64Parser::tokenBranches6713[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6706[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707 }, +x64Token x64Parser::tokenBranches6712[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6723(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6729(x64Operand &operand, int tokenPos) { - operand.operandCoding = 539; + operand.operandCoding = 540; } -x64Token x64Parser::tokenBranches6722[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6723, }, +x64Token x64Parser::tokenBranches6728[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6729, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6721[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722 }, +x64Token x64Parser::tokenBranches6727[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6728 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6720[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721 }, +x64Token x64Parser::tokenBranches6726[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6727 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6689[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, +x64Token x64Parser::tokenBranches6695[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6696 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6726 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6688[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, +x64Token x64Parser::tokenBranches6694[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6695 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6721(x64Operand &operand, int tokenPos) { - operand.operandCoding = 538; + operand.operandCoding = 539; } -x64Token x64Parser::tokenBranches6714[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, +x64Token x64Parser::tokenBranches6720[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6721, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6713[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, +x64Token x64Parser::tokenBranches6719[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6712[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, +x64Token x64Parser::tokenBranches6718[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6719 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6694(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26723,25 +26792,25 @@ void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6687[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6688, x64Parser::tokenBranches6688 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, +x64Token x64Parser::tokenBranches6693[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6694, x64Parser::tokenBranches6694 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6718 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6678[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, +x64Token x64Parser::tokenBranches6684[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6685 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6693 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6585[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678 }, +x64Token x64Parser::tokenBranches6591[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) { - operand.operandCoding = 540; + operand.operandCoding = 541; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26753,53 +26822,53 @@ void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6729[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6730, }, +x64Token x64Parser::tokenBranches6735[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6736, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6728[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729 }, +x64Token x64Parser::tokenBranches6734[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6735 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6736_16[] = { +Coding x64Parser::tokenCoding6742_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_17[] = { +Coding x64Parser::tokenCoding6742_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_18[] = { +Coding x64Parser::tokenCoding6742_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_19[] = { +Coding x64Parser::tokenCoding6742_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6742(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6736_16; - operand.values[17] = tokenCoding6736_17; - operand.values[18] = tokenCoding6736_18; - operand.values[19] = tokenCoding6736_19; + operand.values[16] = tokenCoding6742_16; + operand.values[17] = tokenCoding6742_17; + operand.values[18] = tokenCoding6742_18; + operand.values[19] = tokenCoding6742_19; } -x64Token x64Parser::tokenBranches6735[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6736, }, +x64Token x64Parser::tokenBranches6741[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6742, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6740(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6746(x64Operand &operand, int tokenPos) { - operand.operandCoding = 541; + operand.operandCoding = 542; } -x64Token x64Parser::tokenBranches6739[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6740, }, +x64Token x64Parser::tokenBranches6745[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6746, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6754(x64Operand &operand, int tokenPos) { - operand.operandCoding = 542; + operand.operandCoding = 543; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -26811,13 +26880,13 @@ void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6747[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6748, }, +x64Token x64Parser::tokenBranches6753[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6754, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6756(x64Operand &operand, int tokenPos) { - operand.operandCoding = 543; + operand.operandCoding = 544; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -26829,13 +26898,13 @@ void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6749[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6750, }, +x64Token x64Parser::tokenBranches6755[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6756, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6767(x64Operand &operand, int tokenPos) { - operand.operandCoding = 544; + operand.operandCoding = 545; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26847,13 +26916,13 @@ void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6760[] = { - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6761, }, +x64Token x64Parser::tokenBranches6766[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6767, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) { - operand.operandCoding = 545; + operand.operandCoding = 546; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26865,76 +26934,76 @@ void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6765[] = { - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6766, }, +x64Token x64Parser::tokenBranches6771[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6772, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6759[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765 }, +x64Token x64Parser::tokenBranches6765[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6766 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6771 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6758[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759 }, +x64Token x64Parser::tokenBranches6764[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6765 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6775_16[] = { +Coding x64Parser::tokenCoding6781_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_17[] = { +Coding x64Parser::tokenCoding6781_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_18[] = { +Coding x64Parser::tokenCoding6781_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_19[] = { +Coding x64Parser::tokenCoding6781_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6775(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6781(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6775_16; - operand.values[17] = tokenCoding6775_17; - operand.values[18] = tokenCoding6775_18; - operand.values[19] = tokenCoding6775_19; + operand.values[16] = tokenCoding6781_16; + operand.values[17] = tokenCoding6781_17; + operand.values[18] = tokenCoding6781_18; + operand.values[19] = tokenCoding6781_19; } -x64Token x64Parser::tokenBranches6774[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6775, }, +x64Token x64Parser::tokenBranches6780[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6781, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_16[] = { +Coding x64Parser::tokenCoding6784_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_17[] = { +Coding x64Parser::tokenCoding6784_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_18[] = { +Coding x64Parser::tokenCoding6784_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_19[] = { +Coding x64Parser::tokenCoding6784_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6778_16; - operand.values[17] = tokenCoding6778_17; - operand.values[18] = tokenCoding6778_18; - operand.values[19] = tokenCoding6778_19; + operand.values[16] = tokenCoding6784_16; + operand.values[17] = tokenCoding6784_17; + operand.values[18] = tokenCoding6784_18; + operand.values[19] = tokenCoding6784_19; } -x64Token x64Parser::tokenBranches6777[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, +x64Token x64Parser::tokenBranches6783[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6784, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6764(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26947,9 +27016,9 @@ void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) operand.values[2][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6774(x64Operand &operand, int tokenPos) { - operand.operandCoding = 546; + operand.operandCoding = 547; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26961,9 +27030,9 @@ void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6776(x64Operand &operand, int tokenPos) { - operand.operandCoding = 547; + operand.operandCoding = 548; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26975,41 +27044,41 @@ void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6772_16[] = { +Coding x64Parser::tokenCoding6778_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_17[] = { +Coding x64Parser::tokenCoding6778_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_18[] = { +Coding x64Parser::tokenCoding6778_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_19[] = { +Coding x64Parser::tokenCoding6778_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6772_16; - operand.values[17] = tokenCoding6772_17; - operand.values[18] = tokenCoding6772_18; - operand.values[19] = tokenCoding6772_19; + operand.values[16] = tokenCoding6778_16; + operand.values[17] = tokenCoding6778_17; + operand.values[18] = tokenCoding6778_18; + operand.values[19] = tokenCoding6778_19; } -x64Token x64Parser::tokenBranches6757[] = { - {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6758, x64Parser::tokenBranches6758 }, - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6768, }, - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6770, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6772, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777 }, +x64Token x64Parser::tokenBranches6763[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6764, x64Parser::tokenBranches6764 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6774, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6776, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6780 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6783 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) { - operand.operandCoding = 548; + operand.operandCoding = 549; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27021,13 +27090,13 @@ void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6779[] = { - {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6780, }, +x64Token x64Parser::tokenBranches6785[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6786, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) { - operand.operandCoding = 549; + operand.operandCoding = 550; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27039,9 +27108,9 @@ void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) { - operand.operandCoding = 550; + operand.operandCoding = 551; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27053,98 +27122,98 @@ void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6781[] = { - {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6782, }, - {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6784, }, +x64Token x64Parser::tokenBranches6787[] = { + {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6788, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6790, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6792_16[] = { +Coding x64Parser::tokenCoding6798_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_17[] = { +Coding x64Parser::tokenCoding6798_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_18[] = { +Coding x64Parser::tokenCoding6798_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_19[] = { +Coding x64Parser::tokenCoding6798_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6798(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6792_16; - operand.values[17] = tokenCoding6792_17; - operand.values[18] = tokenCoding6792_18; - operand.values[19] = tokenCoding6792_19; + operand.values[16] = tokenCoding6798_16; + operand.values[17] = tokenCoding6798_17; + operand.values[18] = tokenCoding6798_18; + operand.values[19] = tokenCoding6798_19; } -x64Token x64Parser::tokenBranches6791[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6792, }, +x64Token x64Parser::tokenBranches6797[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6798, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6794_16[] = { +Coding x64Parser::tokenCoding6800_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_17[] = { +Coding x64Parser::tokenCoding6800_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_18[] = { +Coding x64Parser::tokenCoding6800_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_19[] = { +Coding x64Parser::tokenCoding6800_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6800(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6794_16; - operand.values[17] = tokenCoding6794_17; - operand.values[18] = tokenCoding6794_18; - operand.values[19] = tokenCoding6794_19; + operand.values[16] = tokenCoding6800_16; + operand.values[17] = tokenCoding6800_17; + operand.values[18] = tokenCoding6800_18; + operand.values[19] = tokenCoding6800_19; } -x64Token x64Parser::tokenBranches6793[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6794, }, +x64Token x64Parser::tokenBranches6799[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6800, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6796_16[] = { +Coding x64Parser::tokenCoding6802_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_17[] = { +Coding x64Parser::tokenCoding6802_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_18[] = { +Coding x64Parser::tokenCoding6802_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_19[] = { +Coding x64Parser::tokenCoding6802_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6802(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6796_16; - operand.values[17] = tokenCoding6796_17; - operand.values[18] = tokenCoding6796_18; - operand.values[19] = tokenCoding6796_19; + operand.values[16] = tokenCoding6802_16; + operand.values[17] = tokenCoding6802_17; + operand.values[18] = tokenCoding6802_18; + operand.values[19] = tokenCoding6802_19; } -x64Token x64Parser::tokenBranches6795[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, +x64Token x64Parser::tokenBranches6801[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6802, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6791(x64Operand &operand, int tokenPos) { - operand.operandCoding = 549; + operand.operandCoding = 550; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27156,9 +27225,9 @@ void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) { - operand.operandCoding = 550; + operand.operandCoding = 551; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27170,167 +27239,142 @@ void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6787_16[] = { +Coding x64Parser::tokenCoding6793_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_17[] = { +Coding x64Parser::tokenCoding6793_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_18[] = { +Coding x64Parser::tokenCoding6793_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_19[] = { +Coding x64Parser::tokenCoding6793_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6787(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6793(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6787_16; - operand.values[17] = tokenCoding6787_17; - operand.values[18] = tokenCoding6787_18; - operand.values[19] = tokenCoding6787_19; + operand.values[16] = tokenCoding6793_16; + operand.values[17] = tokenCoding6793_17; + operand.values[18] = tokenCoding6793_18; + operand.values[19] = tokenCoding6793_19; } -Coding x64Parser::tokenCoding6788_16[] = { +Coding x64Parser::tokenCoding6794_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_17[] = { +Coding x64Parser::tokenCoding6794_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_18[] = { +Coding x64Parser::tokenCoding6794_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_19[] = { +Coding x64Parser::tokenCoding6794_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6788_16; - operand.values[17] = tokenCoding6788_17; - operand.values[18] = tokenCoding6788_18; - operand.values[19] = tokenCoding6788_19; + operand.values[16] = tokenCoding6794_16; + operand.values[17] = tokenCoding6794_17; + operand.values[18] = tokenCoding6794_18; + operand.values[19] = tokenCoding6794_19; } -Coding x64Parser::tokenCoding6789_16[] = { +Coding x64Parser::tokenCoding6795_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_17[] = { +Coding x64Parser::tokenCoding6795_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_18[] = { +Coding x64Parser::tokenCoding6795_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_19[] = { +Coding x64Parser::tokenCoding6795_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6789(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6795(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6789_16; - operand.values[17] = tokenCoding6789_17; - operand.values[18] = tokenCoding6789_18; - operand.values[19] = tokenCoding6789_19; + operand.values[16] = tokenCoding6795_16; + operand.values[17] = tokenCoding6795_17; + operand.values[18] = tokenCoding6795_18; + operand.values[19] = tokenCoding6795_19; } -Coding x64Parser::tokenCoding6790_16[] = { +Coding x64Parser::tokenCoding6796_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_17[] = { +Coding x64Parser::tokenCoding6796_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_18[] = { +Coding x64Parser::tokenCoding6796_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_19[] = { +Coding x64Parser::tokenCoding6796_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6790_16; - operand.values[17] = tokenCoding6790_17; - operand.values[18] = tokenCoding6790_18; - operand.values[19] = tokenCoding6790_19; -} -x64Token x64Parser::tokenBranches6756[] = { - {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757 }, - {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779 }, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781 }, - {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6785, }, - {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6786, }, - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6787, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6788, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6789, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6790, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding6830_16[] = { + operand.values[16] = tokenCoding6796_16; + operand.values[17] = tokenCoding6796_17; + operand.values[18] = tokenCoding6796_18; + operand.values[19] = tokenCoding6796_19; +} +x64Token x64Parser::tokenBranches6762[] = { + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6763 }, + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6785 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6787 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6791, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6792, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6793, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6794, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6795, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6797 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6799 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6801 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6836_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_17[] = { +Coding x64Parser::tokenCoding6836_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_18[] = { +Coding x64Parser::tokenCoding6836_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_19[] = { +Coding x64Parser::tokenCoding6836_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6830(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6830_16; - operand.values[17] = tokenCoding6830_17; - operand.values[18] = tokenCoding6830_18; - operand.values[19] = tokenCoding6830_19; -} -x64Token x64Parser::tokenBranches6829[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6830, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc6837(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 551; -} -x64Token x64Parser::tokenBranches6836[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6837, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6836(x64Operand &operand, int tokenPos) { - operand.operandCoding = 553; + operand.values[16] = tokenCoding6836_16; + operand.values[17] = tokenCoding6836_17; + operand.values[18] = tokenCoding6836_18; + operand.values[19] = tokenCoding6836_19; } -x64Token x64Parser::tokenBranches6848[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6835[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6834[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6836, }, {x64Token::EOT } }; void x64Parser::TokenFunc6843(x64Operand &operand, int tokenPos) @@ -27349,52 +27393,29 @@ x64Token x64Parser::tokenBranches6854[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6855, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 556; -} -x64Token x64Parser::tokenBranches6864[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6841[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6840[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6859(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) { - operand.operandCoding = 555; + operand.operandCoding = 553; } -x64Token x64Parser::tokenBranches6858[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6859, }, +x64Token x64Parser::tokenBranches6848[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6840(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6861(x64Operand &operand, int tokenPos) { - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + operand.operandCoding = 555; } -x64Token x64Parser::tokenBranches6833[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6840, x64Parser::tokenBranches6840 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6832[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833 }, +x64Token x64Parser::tokenBranches6860[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6861, }, {x64Token::EOT } }; void x64Parser::TokenFunc6871(x64Operand &operand, int tokenPos) @@ -27405,21 +27426,44 @@ x64Token x64Parser::tokenBranches6870[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6871, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6847[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6860 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6846[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6847 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) { - operand.operandCoding = 559; + operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches6882[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, +x64Token x64Parser::tokenBranches6864[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6869[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, +void x64Parser::TokenFunc6846(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6839[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6840 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6846, x64Parser::tokenBranches6846 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6868[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869 }, +x64Token x64Parser::tokenBranches6838[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6839 }, {x64Token::EOT } }; void x64Parser::TokenFunc6877(x64Operand &operand, int tokenPos) @@ -27438,52 +27482,29 @@ x64Token x64Parser::tokenBranches6888[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6889, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 562; -} -x64Token x64Parser::tokenBranches6898[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6875[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6874[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6893(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) { - operand.operandCoding = 561; + operand.operandCoding = 559; } -x64Token x64Parser::tokenBranches6892[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6893, }, +x64Token x64Parser::tokenBranches6882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6874(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6895(x64Operand &operand, int tokenPos) { - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + operand.operandCoding = 561; } -x64Token x64Parser::tokenBranches6867[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6874, x64Parser::tokenBranches6874 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6866[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867 }, +x64Token x64Parser::tokenBranches6894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6895, }, {x64Token::EOT } }; void x64Parser::TokenFunc6905(x64Operand &operand, int tokenPos) @@ -27494,21 +27515,44 @@ x64Token x64Parser::tokenBranches6904[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6905, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6881[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6894 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6880[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6881 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) { - operand.operandCoding = 565; + operand.operandCoding = 562; } -x64Token x64Parser::tokenBranches6916[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, +x64Token x64Parser::tokenBranches6898[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6903[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, +void x64Parser::TokenFunc6880(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6873[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6874 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6880, x64Parser::tokenBranches6880 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6902[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903 }, +x64Token x64Parser::tokenBranches6872[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6873 }, {x64Token::EOT } }; void x64Parser::TokenFunc6911(x64Operand &operand, int tokenPos) @@ -27527,33 +27571,58 @@ x64Token x64Parser::tokenBranches6922[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6923, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 568; -} -x64Token x64Parser::tokenBranches6932[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6909[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6908[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6927(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 565; +} +x64Token x64Parser::tokenBranches6916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6929(x64Operand &operand, int tokenPos) { operand.operandCoding = 567; } -x64Token x64Parser::tokenBranches6926[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6927, }, +x64Token x64Parser::tokenBranches6928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6929, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 569; +} +x64Token x64Parser::tokenBranches6938[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6915[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6928 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6914[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6915 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 568; +} +x64Token x64Parser::tokenBranches6932[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6914(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27565,66 +27634,66 @@ void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6901[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6908, x64Parser::tokenBranches6908 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926 }, +x64Token x64Parser::tokenBranches6907[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6908 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6914, x64Parser::tokenBranches6914 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6900[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901 }, +x64Token x64Parser::tokenBranches6906[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6907 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) { - operand.operandCoding = 569; + operand.operandCoding = 570; } -x64Token x64Parser::tokenBranches6938[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, +x64Token x64Parser::tokenBranches6944[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6937[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, +x64Token x64Parser::tokenBranches6943[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6936[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937 }, +x64Token x64Parser::tokenBranches6942[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6951(x64Operand &operand, int tokenPos) { - operand.operandCoding = 570; + operand.operandCoding = 571; } -x64Token x64Parser::tokenBranches6944[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, +x64Token x64Parser::tokenBranches6950[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6951, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6961(x64Operand &operand, int tokenPos) { - operand.operandCoding = 572; + operand.operandCoding = 573; } -x64Token x64Parser::tokenBranches6954[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, +x64Token x64Parser::tokenBranches6960[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6961, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6943[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, +x64Token x64Parser::tokenBranches6949[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6950 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6960 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6942[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, +x64Token x64Parser::tokenBranches6948[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6949 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6949(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) { - operand.operandCoding = 571; + operand.operandCoding = 572; } -x64Token x64Parser::tokenBranches6948[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6949, }, +x64Token x64Parser::tokenBranches6954[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6948(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27636,34 +27705,34 @@ void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6935[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6942, x64Parser::tokenBranches6942 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948 }, +x64Token x64Parser::tokenBranches6941[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6942 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6948, x64Parser::tokenBranches6948 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6934[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935 }, +x64Token x64Parser::tokenBranches6940[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6941 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6831[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934 }, +x64Token x64Parser::tokenBranches6837[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6838 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6872 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6906 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6940 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6960(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) { - operand.operandCoding = 573; + operand.operandCoding = 574; } -x64Token x64Parser::tokenBranches6959[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6960, }, +x64Token x64Parser::tokenBranches6965[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6966, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) { - operand.operandCoding = 574; + operand.operandCoding = 575; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27675,13 +27744,13 @@ void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6961[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6962, }, +x64Token x64Parser::tokenBranches6967[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) { - operand.operandCoding = 575; + operand.operandCoding = 576; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27693,13 +27762,13 @@ void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6963[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6964, }, +x64Token x64Parser::tokenBranches6969[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6972(x64Operand &operand, int tokenPos) { - operand.operandCoding = 576; + operand.operandCoding = 577; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27711,13 +27780,13 @@ void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6965[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6966, }, +x64Token x64Parser::tokenBranches6971[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6972, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) { - operand.operandCoding = 576; + operand.operandCoding = 577; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27729,13 +27798,13 @@ void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6967[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, +x64Token x64Parser::tokenBranches6973[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6974, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) { - operand.operandCoding = 575; + operand.operandCoding = 576; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27747,159 +27816,159 @@ void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6969[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, +x64Token x64Parser::tokenBranches6975[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6976, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_16[] = { +Coding x64Parser::tokenCoding6980_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_17[] = { +Coding x64Parser::tokenCoding6980_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_18[] = { +Coding x64Parser::tokenCoding6980_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_19[] = { +Coding x64Parser::tokenCoding6980_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6980(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6974_16; - operand.values[17] = tokenCoding6974_17; - operand.values[18] = tokenCoding6974_18; - operand.values[19] = tokenCoding6974_19; + operand.values[16] = tokenCoding6980_16; + operand.values[17] = tokenCoding6980_17; + operand.values[18] = tokenCoding6980_18; + operand.values[19] = tokenCoding6980_19; } -x64Token x64Parser::tokenBranches6973[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6974, }, +x64Token x64Parser::tokenBranches6979[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6980, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_16[] = { +Coding x64Parser::tokenCoding6984_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_17[] = { +Coding x64Parser::tokenCoding6984_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_18[] = { +Coding x64Parser::tokenCoding6984_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_19[] = { +Coding x64Parser::tokenCoding6984_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6978(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6978_16; - operand.values[17] = tokenCoding6978_17; - operand.values[18] = tokenCoding6978_18; - operand.values[19] = tokenCoding6978_19; + operand.values[16] = tokenCoding6984_16; + operand.values[17] = tokenCoding6984_17; + operand.values[18] = tokenCoding6984_18; + operand.values[19] = tokenCoding6984_19; } -x64Token x64Parser::tokenBranches6977[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6978, }, +x64Token x64Parser::tokenBranches6983[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6976[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977 }, +x64Token x64Parser::tokenBranches6982[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_16[] = { +Coding x64Parser::tokenCoding6987_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_17[] = { +Coding x64Parser::tokenCoding6987_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_18[] = { +Coding x64Parser::tokenCoding6987_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_19[] = { +Coding x64Parser::tokenCoding6987_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6981(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6987(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6981_16; - operand.values[17] = tokenCoding6981_17; - operand.values[18] = tokenCoding6981_18; - operand.values[19] = tokenCoding6981_19; + operand.values[16] = tokenCoding6987_16; + operand.values[17] = tokenCoding6987_17; + operand.values[18] = tokenCoding6987_18; + operand.values[19] = tokenCoding6987_19; } -x64Token x64Parser::tokenBranches6980[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6981, }, +x64Token x64Parser::tokenBranches6986[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6987, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6979[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980 }, +x64Token x64Parser::tokenBranches6985[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_16[] = { +Coding x64Parser::tokenCoding6990_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_17[] = { +Coding x64Parser::tokenCoding6990_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_18[] = { +Coding x64Parser::tokenCoding6990_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_19[] = { +Coding x64Parser::tokenCoding6990_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6984_16; - operand.values[17] = tokenCoding6984_17; - operand.values[18] = tokenCoding6984_18; - operand.values[19] = tokenCoding6984_19; + operand.values[16] = tokenCoding6990_16; + operand.values[17] = tokenCoding6990_17; + operand.values[18] = tokenCoding6990_18; + operand.values[19] = tokenCoding6990_19; } -x64Token x64Parser::tokenBranches6983[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, +x64Token x64Parser::tokenBranches6989[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6990, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6982[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, +x64Token x64Parser::tokenBranches6988[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6989 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6996(x64Operand &operand, int tokenPos) { - operand.operandCoding = 577; + operand.operandCoding = 578; } -x64Token x64Parser::tokenBranches6989[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6990, }, +x64Token x64Parser::tokenBranches6995[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6996, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6998(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) { - operand.operandCoding = 578; + operand.operandCoding = 579; } -x64Token x64Parser::tokenBranches6997[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6998, }, +x64Token x64Parser::tokenBranches7003[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7012(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) { - operand.operandCoding = 580; + operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches7011[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7012, }, +x64Token x64Parser::tokenBranches7017[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27912,7 +27981,7 @@ void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27925,24 +27994,24 @@ void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6996[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6997, x64Parser::tokenBranches6997 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7011, x64Parser::tokenBranches7011 }, +x64Token x64Parser::tokenBranches7002[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6995[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996 }, +x64Token x64Parser::tokenBranches7001[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7002 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7010(x64Operand &operand, int tokenPos) { - operand.operandCoding = 579; + operand.operandCoding = 580; } -x64Token x64Parser::tokenBranches7003[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, +x64Token x64Parser::tokenBranches7009[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7010, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27955,7 +28024,7 @@ void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7001(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27967,7 +28036,7 @@ void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7009(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27980,49 +28049,49 @@ void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6988[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6989, x64Parser::tokenBranches6989 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, +x64Token x64Parser::tokenBranches6994[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7001, x64Parser::tokenBranches7001 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7009, x64Parser::tokenBranches7009 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6987[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988 }, +x64Token x64Parser::tokenBranches6993[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6994 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6986[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987 }, +x64Token x64Parser::tokenBranches6992[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6993 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6985[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, +x64Token x64Parser::tokenBranches6991[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6992 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7024(x64Operand &operand, int tokenPos) { - operand.operandCoding = 581; + operand.operandCoding = 582; } -x64Token x64Parser::tokenBranches7017[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, +x64Token x64Parser::tokenBranches7023[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7024, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7026(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) { - operand.operandCoding = 582; + operand.operandCoding = 583; } -x64Token x64Parser::tokenBranches7025[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7026, }, +x64Token x64Parser::tokenBranches7031[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7040(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) { - operand.operandCoding = 584; + operand.operandCoding = 585; } -x64Token x64Parser::tokenBranches7039[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7040, }, +x64Token x64Parser::tokenBranches7045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28035,7 +28104,7 @@ void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28048,24 +28117,24 @@ void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7024[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7025, x64Parser::tokenBranches7025 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7039, x64Parser::tokenBranches7039 }, +x64Token x64Parser::tokenBranches7030[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7023[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024 }, +x64Token x64Parser::tokenBranches7029[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7030 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7038(x64Operand &operand, int tokenPos) { - operand.operandCoding = 583; + operand.operandCoding = 584; } -x64Token x64Parser::tokenBranches7031[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, +x64Token x64Parser::tokenBranches7037[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7038, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28078,7 +28147,7 @@ void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7029(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -28090,7 +28159,7 @@ void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7037(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28103,49 +28172,49 @@ void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7016[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, +x64Token x64Parser::tokenBranches7022[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7029, x64Parser::tokenBranches7029 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7037, x64Parser::tokenBranches7037 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7015[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016 }, +x64Token x64Parser::tokenBranches7021[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7022 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7014[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015 }, +x64Token x64Parser::tokenBranches7020[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7021 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7013[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014 }, +x64Token x64Parser::tokenBranches7019[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7020 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7052(x64Operand &operand, int tokenPos) { - operand.operandCoding = 585; + operand.operandCoding = 586; } -x64Token x64Parser::tokenBranches7045[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, +x64Token x64Parser::tokenBranches7051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7052, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7054(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) { - operand.operandCoding = 586; + operand.operandCoding = 587; } -x64Token x64Parser::tokenBranches7053[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7054, }, +x64Token x64Parser::tokenBranches7059[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7068(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7074(x64Operand &operand, int tokenPos) { - operand.operandCoding = 588; + operand.operandCoding = 589; } -x64Token x64Parser::tokenBranches7067[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7068, }, +x64Token x64Parser::tokenBranches7073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7074, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28158,7 +28227,7 @@ void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28171,24 +28240,24 @@ void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7052[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7053, x64Parser::tokenBranches7053 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7067, x64Parser::tokenBranches7067 }, +x64Token x64Parser::tokenBranches7058[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7051[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052 }, +x64Token x64Parser::tokenBranches7057[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7058 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7066(x64Operand &operand, int tokenPos) { - operand.operandCoding = 587; + operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches7059[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, +x64Token x64Parser::tokenBranches7065[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7066, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28201,7 +28270,7 @@ void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7057(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -28213,7 +28282,7 @@ void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7065(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28226,27 +28295,27 @@ void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7044[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, +x64Token x64Parser::tokenBranches7050[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7057, x64Parser::tokenBranches7057 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7065, x64Parser::tokenBranches7065 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7043[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044 }, +x64Token x64Parser::tokenBranches7049[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7050 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7042[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043 }, +x64Token x64Parser::tokenBranches7048[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7049 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7041[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042 }, +x64Token x64Parser::tokenBranches7047[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7048 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7078(x64Operand &operand, int tokenPos) { - operand.operandCoding = 589; + operand.operandCoding = 590; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28258,45 +28327,45 @@ void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7092_16[] = { +Coding x64Parser::tokenCoding7098_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_17[] = { +Coding x64Parser::tokenCoding7098_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_18[] = { +Coding x64Parser::tokenCoding7098_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_19[] = { +Coding x64Parser::tokenCoding7098_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7092(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7098(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7092_16; - operand.values[17] = tokenCoding7092_17; - operand.values[18] = tokenCoding7092_18; - operand.values[19] = tokenCoding7092_19; + operand.values[16] = tokenCoding7098_16; + operand.values[17] = tokenCoding7098_17; + operand.values[18] = tokenCoding7098_18; + operand.values[19] = tokenCoding7098_19; } -x64Token x64Parser::tokenBranches7071[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7072, }, - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7092, }, +x64Token x64Parser::tokenBranches7077[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7078, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7098, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7070[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071 }, +x64Token x64Parser::tokenBranches7076[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7077 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7069[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070 }, +x64Token x64Parser::tokenBranches7075[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7076 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7082(x64Operand &operand, int tokenPos) { - operand.operandCoding = 590; + operand.operandCoding = 591; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28308,50 +28377,50 @@ void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7096_16[] = { +Coding x64Parser::tokenCoding7102_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_17[] = { +Coding x64Parser::tokenCoding7102_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_23[] = { +Coding x64Parser::tokenCoding7102_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_18[] = { +Coding x64Parser::tokenCoding7102_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_19[] = { +Coding x64Parser::tokenCoding7102_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7096(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7102(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7096_16; - operand.values[17] = tokenCoding7096_17; - operand.values[23] = tokenCoding7096_23; - operand.values[18] = tokenCoding7096_18; - operand.values[19] = tokenCoding7096_19; + operand.values[16] = tokenCoding7102_16; + operand.values[17] = tokenCoding7102_17; + operand.values[23] = tokenCoding7102_23; + operand.values[18] = tokenCoding7102_18; + operand.values[19] = tokenCoding7102_19; } -x64Token x64Parser::tokenBranches7075[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7076, }, - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7096, }, +x64Token x64Parser::tokenBranches7081[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7082, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7102, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7074[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075 }, +x64Token x64Parser::tokenBranches7080[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7081 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7073[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074 }, +x64Token x64Parser::tokenBranches7079[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7080 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7086(x64Operand &operand, int tokenPos) { - operand.operandCoding = 591; + operand.operandCoding = 592; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28363,46 +28432,46 @@ void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7100_16[] = { +Coding x64Parser::tokenCoding7106_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_17[] = { +Coding x64Parser::tokenCoding7106_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_18[] = { +Coding x64Parser::tokenCoding7106_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_19[] = { +Coding x64Parser::tokenCoding7106_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7100(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7106(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7100_16; - operand.values[17] = tokenCoding7100_17; - operand.values[18] = tokenCoding7100_18; - operand.values[19] = tokenCoding7100_19; + operand.values[16] = tokenCoding7106_16; + operand.values[17] = tokenCoding7106_17; + operand.values[18] = tokenCoding7106_18; + operand.values[19] = tokenCoding7106_19; } -x64Token x64Parser::tokenBranches7079[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7080, }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7100, }, +x64Token x64Parser::tokenBranches7085[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7086, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7106, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7078[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079 }, +x64Token x64Parser::tokenBranches7084[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7085 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7077[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078 }, +x64Token x64Parser::tokenBranches7083[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7084 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7090(x64Operand &operand, int tokenPos) { - operand.operandCoding = 592; + operand.operandCoding = 593; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28414,46 +28483,46 @@ void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7104_16[] = { +Coding x64Parser::tokenCoding7110_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_17[] = { +Coding x64Parser::tokenCoding7110_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_18[] = { +Coding x64Parser::tokenCoding7110_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_19[] = { +Coding x64Parser::tokenCoding7110_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7104(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7110(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7104_16; - operand.values[17] = tokenCoding7104_17; - operand.values[18] = tokenCoding7104_18; - operand.values[19] = tokenCoding7104_19; + operand.values[16] = tokenCoding7110_16; + operand.values[17] = tokenCoding7110_17; + operand.values[18] = tokenCoding7110_18; + operand.values[19] = tokenCoding7110_19; } -x64Token x64Parser::tokenBranches7083[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7084, }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7104, }, +x64Token x64Parser::tokenBranches7089[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7090, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7110, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7082[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083 }, +x64Token x64Parser::tokenBranches7088[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7089 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7081[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082 }, +x64Token x64Parser::tokenBranches7087[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7088 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7094(x64Operand &operand, int tokenPos) { - operand.operandCoding = 593; + operand.operandCoding = 594; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28465,60 +28534,60 @@ void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7108_16[] = { +Coding x64Parser::tokenCoding7114_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_17[] = { +Coding x64Parser::tokenCoding7114_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_18[] = { +Coding x64Parser::tokenCoding7114_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_19[] = { +Coding x64Parser::tokenCoding7114_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7108(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7114(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7108_16; - operand.values[17] = tokenCoding7108_17; - operand.values[18] = tokenCoding7108_18; - operand.values[19] = tokenCoding7108_19; + operand.values[16] = tokenCoding7114_16; + operand.values[17] = tokenCoding7114_17; + operand.values[18] = tokenCoding7114_18; + operand.values[19] = tokenCoding7114_19; } -x64Token x64Parser::tokenBranches7087[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7088, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7108, }, +x64Token x64Parser::tokenBranches7093[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7094, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7114, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7086[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087 }, +x64Token x64Parser::tokenBranches7092[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7093 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7085[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086 }, +x64Token x64Parser::tokenBranches7091[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7092 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_16[] = { +Coding x64Parser::tokenCoding7119_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_17[] = { +Coding x64Parser::tokenCoding7119_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_18[] = { +Coding x64Parser::tokenCoding7119_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_19[] = { +Coding x64Parser::tokenCoding7119_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7119(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -28531,47 +28600,47 @@ void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7113_16; - operand.values[17] = tokenCoding7113_17; - operand.values[18] = tokenCoding7113_18; - operand.values[19] = tokenCoding7113_19; + operand.values[16] = tokenCoding7119_16; + operand.values[17] = tokenCoding7119_17; + operand.values[18] = tokenCoding7119_18; + operand.values[19] = tokenCoding7119_19; } -x64Token x64Parser::tokenBranches7112[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7113, }, +x64Token x64Parser::tokenBranches7118[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7119, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7111[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112 }, +x64Token x64Parser::tokenBranches7117[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7118 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7110[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111 }, +x64Token x64Parser::tokenBranches7116[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7117 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7109[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110 }, +x64Token x64Parser::tokenBranches7115[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_16[] = { +Coding x64Parser::tokenCoding7124_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_17[] = { +Coding x64Parser::tokenCoding7124_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_18[] = { +Coding x64Parser::tokenCoding7124_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_19[] = { +Coding x64Parser::tokenCoding7124_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7124(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28582,47 +28651,47 @@ void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7118_16; - operand.values[17] = tokenCoding7118_17; - operand.values[18] = tokenCoding7118_18; - operand.values[19] = tokenCoding7118_19; + operand.values[16] = tokenCoding7124_16; + operand.values[17] = tokenCoding7124_17; + operand.values[18] = tokenCoding7124_18; + operand.values[19] = tokenCoding7124_19; } -x64Token x64Parser::tokenBranches7117[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7118, }, +x64Token x64Parser::tokenBranches7123[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7124, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7116[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117 }, +x64Token x64Parser::tokenBranches7122[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7123 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7115[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, +x64Token x64Parser::tokenBranches7121[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7122 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7114[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, +x64Token x64Parser::tokenBranches7120[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7123_16[] = { +Coding x64Parser::tokenCoding7129_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_17[] = { +Coding x64Parser::tokenCoding7129_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_18[] = { +Coding x64Parser::tokenCoding7129_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_19[] = { +Coding x64Parser::tokenCoding7129_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7129(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28633,47 +28702,47 @@ void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7123_16; - operand.values[17] = tokenCoding7123_17; - operand.values[18] = tokenCoding7123_18; - operand.values[19] = tokenCoding7123_19; + operand.values[16] = tokenCoding7129_16; + operand.values[17] = tokenCoding7129_17; + operand.values[18] = tokenCoding7129_18; + operand.values[19] = tokenCoding7129_19; } -x64Token x64Parser::tokenBranches7122[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7123, }, +x64Token x64Parser::tokenBranches7128[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7129, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7121[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122 }, +x64Token x64Parser::tokenBranches7127[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7128 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7120[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, +x64Token x64Parser::tokenBranches7126[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7127 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7119[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, +x64Token x64Parser::tokenBranches7125[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7128_16[] = { +Coding x64Parser::tokenCoding7134_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_17[] = { +Coding x64Parser::tokenCoding7134_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_18[] = { +Coding x64Parser::tokenCoding7134_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_19[] = { +Coding x64Parser::tokenCoding7134_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28684,39 +28753,39 @@ void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7128_16; - operand.values[17] = tokenCoding7128_17; - operand.values[18] = tokenCoding7128_18; - operand.values[19] = tokenCoding7128_19; + operand.values[16] = tokenCoding7134_16; + operand.values[17] = tokenCoding7134_17; + operand.values[18] = tokenCoding7134_18; + operand.values[19] = tokenCoding7134_19; } -x64Token x64Parser::tokenBranches7127[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7128, }, +x64Token x64Parser::tokenBranches7133[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7134, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7126[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127 }, +x64Token x64Parser::tokenBranches7132[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7133 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7125[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, +x64Token x64Parser::tokenBranches7131[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7132 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7124[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, +x64Token x64Parser::tokenBranches7130[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7131 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7279_18[] = { +Coding x64Parser::tokenCoding7285_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7279_19[] = { +Coding x64Parser::tokenCoding7285_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7285(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28727,31 +28796,31 @@ void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7279_18; - operand.values[19] = tokenCoding7279_19; + operand.values[18] = tokenCoding7285_18; + operand.values[19] = tokenCoding7285_19; } -x64Token x64Parser::tokenBranches7278[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7279, }, +x64Token x64Parser::tokenBranches7284[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7285, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7131_16[] = { +Coding x64Parser::tokenCoding7137_16[] = { { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_17[] = { +Coding x64Parser::tokenCoding7137_17[] = { { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_18[] = { +Coding x64Parser::tokenCoding7137_18[] = { { CODING_NAME("creg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_19[] = { +Coding x64Parser::tokenCoding7137_19[] = { { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) { operand.values[30] = new Coding[2]; CleanupValues.push_back(operand.values[30]); @@ -28762,29 +28831,29 @@ void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) operand.values[30]->unary = 0; operand.values[30]->binary = 0; operand.values[30][1].type = Coding::eot; - operand.values[16] = tokenCoding7131_16; - operand.values[17] = tokenCoding7131_17; - operand.values[18] = tokenCoding7131_18; - operand.values[19] = tokenCoding7131_19; + operand.values[16] = tokenCoding7137_16; + operand.values[17] = tokenCoding7137_17; + operand.values[18] = tokenCoding7137_18; + operand.values[19] = tokenCoding7137_19; } -Coding x64Parser::tokenCoding7134_16[] = { +Coding x64Parser::tokenCoding7140_16[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_17[] = { +Coding x64Parser::tokenCoding7140_17[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_18[] = { +Coding x64Parser::tokenCoding7140_18[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_19[] = { +Coding x64Parser::tokenCoding7140_19[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) { operand.values[31] = new Coding[2]; CleanupValues.push_back(operand.values[31]); @@ -28795,29 +28864,29 @@ void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) operand.values[31]->unary = 0; operand.values[31]->binary = 0; operand.values[31][1].type = Coding::eot; - operand.values[16] = tokenCoding7134_16; - operand.values[17] = tokenCoding7134_17; - operand.values[18] = tokenCoding7134_18; - operand.values[19] = tokenCoding7134_19; + operand.values[16] = tokenCoding7140_16; + operand.values[17] = tokenCoding7140_17; + operand.values[18] = tokenCoding7140_18; + operand.values[19] = tokenCoding7140_19; } -Coding x64Parser::tokenCoding7137_16[] = { +Coding x64Parser::tokenCoding7143_16[] = { { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_17[] = { +Coding x64Parser::tokenCoding7143_17[] = { { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_18[] = { +Coding x64Parser::tokenCoding7143_18[] = { { CODING_NAME("treg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_19[] = { +Coding x64Parser::tokenCoding7143_19[] = { { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) { operand.values[32] = new Coding[2]; CleanupValues.push_back(operand.values[32]); @@ -28828,28 +28897,28 @@ void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) operand.values[32]->unary = 0; operand.values[32]->binary = 0; operand.values[32][1].type = Coding::eot; - operand.values[16] = tokenCoding7137_16; - operand.values[17] = tokenCoding7137_17; - operand.values[18] = tokenCoding7137_18; - operand.values[19] = tokenCoding7137_19; + operand.values[16] = tokenCoding7143_16; + operand.values[17] = tokenCoding7143_17; + operand.values[18] = tokenCoding7143_18; + operand.values[19] = tokenCoding7143_19; } -Coding x64Parser::tokenCoding7264_16[] = { +Coding x64Parser::tokenCoding7270_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_17[] = { +Coding x64Parser::tokenCoding7270_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_18[] = { +Coding x64Parser::tokenCoding7270_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_19[] = { +Coding x64Parser::tokenCoding7270_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7270(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -28860,72 +28929,72 @@ void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7264_16; - operand.values[17] = tokenCoding7264_17; - operand.values[18] = tokenCoding7264_18; - operand.values[19] = tokenCoding7264_19; + operand.values[16] = tokenCoding7270_16; + operand.values[17] = tokenCoding7270_17; + operand.values[18] = tokenCoding7270_18; + operand.values[19] = tokenCoding7270_19; } -x64Token x64Parser::tokenBranches7130[] = { - {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7131, }, - {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7134, }, - {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7137, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278 }, +x64Token x64Parser::tokenBranches7136[] = { + {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7137, }, + {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7140, }, + {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7143, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7270, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7129[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, +x64Token x64Parser::tokenBranches7135[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7136 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7149(x64Operand &operand, int tokenPos) { - operand.operandCoding = 594; + operand.operandCoding = 595; } -x64Token x64Parser::tokenBranches7142[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7143, }, +x64Token x64Parser::tokenBranches7148[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7149, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7141[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142 }, +x64Token x64Parser::tokenBranches7147[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7148 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7140[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141 }, +x64Token x64Parser::tokenBranches7146[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7151(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) { - operand.operandCoding = 595; + operand.operandCoding = 596; } -x64Token x64Parser::tokenBranches7150[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7151, }, +x64Token x64Parser::tokenBranches7156[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7149[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150 }, +x64Token x64Parser::tokenBranches7155[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7148[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149 }, +x64Token x64Parser::tokenBranches7154[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7165(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) { - operand.operandCoding = 597; + operand.operandCoding = 598; } -x64Token x64Parser::tokenBranches7164[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7165, }, +x64Token x64Parser::tokenBranches7170[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7171, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7163[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164 }, +x64Token x64Parser::tokenBranches7169[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7162[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163 }, +x64Token x64Parser::tokenBranches7168[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28938,7 +29007,7 @@ void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28951,32 +29020,32 @@ void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7147[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7148, x64Parser::tokenBranches7148 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7162, x64Parser::tokenBranches7162 }, +x64Token x64Parser::tokenBranches7153[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7146[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, +x64Token x64Parser::tokenBranches7152[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7153 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7163(x64Operand &operand, int tokenPos) { - operand.operandCoding = 596; + operand.operandCoding = 597; } -x64Token x64Parser::tokenBranches7156[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, +x64Token x64Parser::tokenBranches7162[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7163, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7155[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, +x64Token x64Parser::tokenBranches7161[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7162 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7154[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, +x64Token x64Parser::tokenBranches7160[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7161 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28989,7 +29058,7 @@ void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7152(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29001,7 +29070,7 @@ void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7160(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29014,29 +29083,29 @@ void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7139[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7140, x64Parser::tokenBranches7140 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, +x64Token x64Parser::tokenBranches7145[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7152, x64Parser::tokenBranches7152 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7160, x64Parser::tokenBranches7160 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7225_16[] = { +Coding x64Parser::tokenCoding7231_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_17[] = { +Coding x64Parser::tokenCoding7231_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_18[] = { +Coding x64Parser::tokenCoding7231_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_19[] = { +Coding x64Parser::tokenCoding7231_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7231(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29047,32 +29116,32 @@ void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7225_16; - operand.values[17] = tokenCoding7225_17; - operand.values[18] = tokenCoding7225_18; - operand.values[19] = tokenCoding7225_19; + operand.values[16] = tokenCoding7231_16; + operand.values[17] = tokenCoding7231_17; + operand.values[18] = tokenCoding7231_18; + operand.values[19] = tokenCoding7231_19; } -Coding x64Parser::tokenCoding7229_16[] = { +Coding x64Parser::tokenCoding7235_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_17[] = { +Coding x64Parser::tokenCoding7235_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_23[] = { +Coding x64Parser::tokenCoding7235_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_18[] = { +Coding x64Parser::tokenCoding7235_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_19[] = { +Coding x64Parser::tokenCoding7235_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7235(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29083,75 +29152,75 @@ void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7229_16; - operand.values[17] = tokenCoding7229_17; - operand.values[23] = tokenCoding7229_23; - operand.values[18] = tokenCoding7229_18; - operand.values[19] = tokenCoding7229_19; + operand.values[16] = tokenCoding7235_16; + operand.values[17] = tokenCoding7235_17; + operand.values[23] = tokenCoding7235_23; + operand.values[18] = tokenCoding7235_18; + operand.values[19] = tokenCoding7235_19; } -x64Token x64Parser::tokenBranches7224[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7225, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7229, }, +x64Token x64Parser::tokenBranches7230[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7231, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7235, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7223[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224 }, +x64Token x64Parser::tokenBranches7229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7230 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7138[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223 }, +x64Token x64Parser::tokenBranches7144[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7145 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7229 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7177(x64Operand &operand, int tokenPos) { - operand.operandCoding = 598; + operand.operandCoding = 599; } -x64Token x64Parser::tokenBranches7170[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7171, }, +x64Token x64Parser::tokenBranches7176[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7177, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7169[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, +x64Token x64Parser::tokenBranches7175[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7176 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7168[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, +x64Token x64Parser::tokenBranches7174[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7179(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) { - operand.operandCoding = 599; + operand.operandCoding = 600; } -x64Token x64Parser::tokenBranches7178[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7179, }, +x64Token x64Parser::tokenBranches7184[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7177[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178 }, +x64Token x64Parser::tokenBranches7183[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7176[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177 }, +x64Token x64Parser::tokenBranches7182[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7193(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) { - operand.operandCoding = 601; + operand.operandCoding = 602; } -x64Token x64Parser::tokenBranches7192[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7193, }, +x64Token x64Parser::tokenBranches7198[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7199, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7191[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192 }, +x64Token x64Parser::tokenBranches7197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7190[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191 }, +x64Token x64Parser::tokenBranches7196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29164,7 +29233,7 @@ void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29177,32 +29246,32 @@ void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7175[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7176, x64Parser::tokenBranches7176 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7190, x64Parser::tokenBranches7190 }, +x64Token x64Parser::tokenBranches7181[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7174[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, +x64Token x64Parser::tokenBranches7180[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7181 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7191(x64Operand &operand, int tokenPos) { - operand.operandCoding = 600; + operand.operandCoding = 601; } -x64Token x64Parser::tokenBranches7184[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, +x64Token x64Parser::tokenBranches7190[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7191, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7183[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, +x64Token x64Parser::tokenBranches7189[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7190 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7182[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, +x64Token x64Parser::tokenBranches7188[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7189 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29215,7 +29284,7 @@ void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7180(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29227,7 +29296,7 @@ void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7188(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29240,30 +29309,30 @@ void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7167[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, +x64Token x64Parser::tokenBranches7173[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7180, x64Parser::tokenBranches7180 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7188, x64Parser::tokenBranches7188 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7233_16[] = { +Coding x64Parser::tokenCoding7239_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_17[] = { +Coding x64Parser::tokenCoding7239_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_18[] = { +Coding x64Parser::tokenCoding7239_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_19[] = { +Coding x64Parser::tokenCoding7239_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7239(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29274,28 +29343,28 @@ void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7233_16; - operand.values[17] = tokenCoding7233_17; - operand.values[18] = tokenCoding7233_18; - operand.values[19] = tokenCoding7233_19; + operand.values[16] = tokenCoding7239_16; + operand.values[17] = tokenCoding7239_17; + operand.values[18] = tokenCoding7239_18; + operand.values[19] = tokenCoding7239_19; } -Coding x64Parser::tokenCoding7258_16[] = { +Coding x64Parser::tokenCoding7264_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_17[] = { +Coding x64Parser::tokenCoding7264_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_18[] = { +Coding x64Parser::tokenCoding7264_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_19[] = { +Coding x64Parser::tokenCoding7264_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29306,106 +29375,39 @@ void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7258_16; - operand.values[17] = tokenCoding7258_17; - operand.values[18] = tokenCoding7258_18; - operand.values[19] = tokenCoding7258_19; -} -x64Token x64Parser::tokenBranches7232[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7233, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7258, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7231[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7166[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 602; + operand.values[16] = tokenCoding7264_16; + operand.values[17] = tokenCoding7264_17; + operand.values[18] = tokenCoding7264_18; + operand.values[19] = tokenCoding7264_19; } -x64Token x64Parser::tokenBranches7198[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7199, }, +x64Token x64Parser::tokenBranches7238[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7239, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7197[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, +x64Token x64Parser::tokenBranches7237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7238 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7196[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, +x64Token x64Parser::tokenBranches7172[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7173 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7237 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7207(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7205(x64Operand &operand, int tokenPos) { operand.operandCoding = 603; } -x64Token x64Parser::tokenBranches7206[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7207, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7205[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206 }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches7204[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7221(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 605; -} -x64Token x64Parser::tokenBranches7220[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7221, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7219[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7218[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219 }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7205, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7204(x64Operand &operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7218(x64Operand &operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} x64Token x64Parser::tokenBranches7203[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7204, x64Parser::tokenBranches7204 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7218, x64Parser::tokenBranches7218 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7204 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches7202[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, {x64Token::EOT } }; void x64Parser::TokenFunc7213(x64Operand &operand, int tokenPos) @@ -29424,7 +29426,23 @@ x64Token x64Parser::tokenBranches7210[] = { {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7227(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 606; +} +x64Token x64Parser::tokenBranches7226[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7227, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7226 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7224[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7225 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29437,7 +29455,58 @@ void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } +void x64Parser::TokenFunc7224(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7209[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7224, x64Parser::tokenBranches7224 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7208[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7209 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7219(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 605; +} +x64Token x64Parser::tokenBranches7218[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7219, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7217[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7218 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7216[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7217 }, + {x64Token::EOT } +}; void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7208(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29449,7 +29518,7 @@ void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7216(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29462,30 +29531,30 @@ void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7195[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, +x64Token x64Parser::tokenBranches7201[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7208, x64Parser::tokenBranches7208 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7216, x64Parser::tokenBranches7216 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7237_16[] = { +Coding x64Parser::tokenCoding7243_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_17[] = { +Coding x64Parser::tokenCoding7243_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_18[] = { +Coding x64Parser::tokenCoding7243_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_19[] = { +Coding x64Parser::tokenCoding7243_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7243(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29496,42 +29565,42 @@ void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7237_16; - operand.values[17] = tokenCoding7237_17; - operand.values[18] = tokenCoding7237_18; - operand.values[19] = tokenCoding7237_19; + operand.values[16] = tokenCoding7243_16; + operand.values[17] = tokenCoding7243_17; + operand.values[18] = tokenCoding7243_18; + operand.values[19] = tokenCoding7243_19; } -x64Token x64Parser::tokenBranches7236[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7237, }, +x64Token x64Parser::tokenBranches7242[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7243, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7235[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236 }, +x64Token x64Parser::tokenBranches7241[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7242 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7194[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235 }, +x64Token x64Parser::tokenBranches7200[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7201 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7241 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7241_16[] = { +Coding x64Parser::tokenCoding7247_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_17[] = { +Coding x64Parser::tokenCoding7247_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_18[] = { +Coding x64Parser::tokenCoding7247_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_19[] = { +Coding x64Parser::tokenCoding7247_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7247(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29542,142 +29611,142 @@ void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7241_16; - operand.values[17] = tokenCoding7241_17; - operand.values[18] = tokenCoding7241_18; - operand.values[19] = tokenCoding7241_19; + operand.values[16] = tokenCoding7247_16; + operand.values[17] = tokenCoding7247_17; + operand.values[18] = tokenCoding7247_18; + operand.values[19] = tokenCoding7247_19; } -x64Token x64Parser::tokenBranches7240[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7241, }, +x64Token x64Parser::tokenBranches7246[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7247, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7239[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240 }, +x64Token x64Parser::tokenBranches7245[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7246 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7238[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239 }, +x64Token x64Parser::tokenBranches7244[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7245 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7245_16[] = { +Coding x64Parser::tokenCoding7251_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_17[] = { +Coding x64Parser::tokenCoding7251_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_18[] = { +Coding x64Parser::tokenCoding7251_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_19[] = { +Coding x64Parser::tokenCoding7251_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7245(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7245_16; - operand.values[17] = tokenCoding7245_17; - operand.values[18] = tokenCoding7245_18; - operand.values[19] = tokenCoding7245_19; + operand.values[16] = tokenCoding7251_16; + operand.values[17] = tokenCoding7251_17; + operand.values[18] = tokenCoding7251_18; + operand.values[19] = tokenCoding7251_19; } -x64Token x64Parser::tokenBranches7244[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7245, }, +x64Token x64Parser::tokenBranches7250[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7251, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7248_16[] = { +Coding x64Parser::tokenCoding7254_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_17[] = { +Coding x64Parser::tokenCoding7254_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_18[] = { +Coding x64Parser::tokenCoding7254_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_19[] = { +Coding x64Parser::tokenCoding7254_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7248_16; - operand.values[17] = tokenCoding7248_17; - operand.values[18] = tokenCoding7248_18; - operand.values[19] = tokenCoding7248_19; + operand.values[16] = tokenCoding7254_16; + operand.values[17] = tokenCoding7254_17; + operand.values[18] = tokenCoding7254_18; + operand.values[19] = tokenCoding7254_19; } -Coding x64Parser::tokenCoding7251_16[] = { +Coding x64Parser::tokenCoding7257_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_17[] = { +Coding x64Parser::tokenCoding7257_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_18[] = { +Coding x64Parser::tokenCoding7257_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_19[] = { +Coding x64Parser::tokenCoding7257_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7257(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7251_16; - operand.values[17] = tokenCoding7251_17; - operand.values[18] = tokenCoding7251_18; - operand.values[19] = tokenCoding7251_19; + operand.values[16] = tokenCoding7257_16; + operand.values[17] = tokenCoding7257_17; + operand.values[18] = tokenCoding7257_18; + operand.values[19] = tokenCoding7257_19; } -Coding x64Parser::tokenCoding7254_16[] = { +Coding x64Parser::tokenCoding7260_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_17[] = { +Coding x64Parser::tokenCoding7260_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_18[] = { +Coding x64Parser::tokenCoding7260_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_19[] = { +Coding x64Parser::tokenCoding7260_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7260(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7254_16; - operand.values[17] = tokenCoding7254_17; - operand.values[18] = tokenCoding7254_18; - operand.values[19] = tokenCoding7254_19; + operand.values[16] = tokenCoding7260_16; + operand.values[17] = tokenCoding7260_17; + operand.values[18] = tokenCoding7260_18; + operand.values[19] = tokenCoding7260_19; } -x64Token x64Parser::tokenBranches7243[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7248, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7251, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7254, }, +x64Token x64Parser::tokenBranches7249[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7250 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7254, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7257, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7260, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7242[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243 }, +x64Token x64Parser::tokenBranches7248[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7249 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7275_18[] = { +Coding x64Parser::tokenCoding7281_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7275_19[] = { +Coding x64Parser::tokenCoding7281_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7281(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -29688,31 +29757,31 @@ void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7275_18; - operand.values[19] = tokenCoding7275_19; + operand.values[18] = tokenCoding7281_18; + operand.values[19] = tokenCoding7281_19; } -x64Token x64Parser::tokenBranches7274[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7275, }, +x64Token x64Parser::tokenBranches7280[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7281, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_16[] = { +Coding x64Parser::tokenCoding7267_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_17[] = { +Coding x64Parser::tokenCoding7267_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_18[] = { +Coding x64Parser::tokenCoding7267_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_19[] = { +Coding x64Parser::tokenCoding7267_19[] = { { CODING_NAME("segm") Coding::stateFunc, 4 }, { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29723,32 +29792,32 @@ void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7261_16; - operand.values[17] = tokenCoding7261_17; - operand.values[18] = tokenCoding7261_18; - operand.values[19] = tokenCoding7261_19; + operand.values[16] = tokenCoding7267_16; + operand.values[17] = tokenCoding7267_17; + operand.values[18] = tokenCoding7267_18; + operand.values[19] = tokenCoding7267_19; } -x64Token x64Parser::tokenBranches7260[] = { - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7261, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274 }, +x64Token x64Parser::tokenBranches7266[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7259[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260 }, +x64Token x64Parser::tokenBranches7265[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7283_18[] = { +Coding x64Parser::tokenCoding7289_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7283_19[] = { +Coding x64Parser::tokenCoding7289_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7289(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -29759,30 +29828,30 @@ void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7283_18; - operand.values[19] = tokenCoding7283_19; + operand.values[18] = tokenCoding7289_18; + operand.values[19] = tokenCoding7289_19; } -x64Token x64Parser::tokenBranches7282[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7283, }, +x64Token x64Parser::tokenBranches7288[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7289, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_16[] = { +Coding x64Parser::tokenCoding7273_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_17[] = { +Coding x64Parser::tokenCoding7273_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_18[] = { +Coding x64Parser::tokenCoding7273_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_19[] = { +Coding x64Parser::tokenCoding7273_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7273(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29793,29 +29862,29 @@ void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7267_16; - operand.values[17] = tokenCoding7267_17; - operand.values[18] = tokenCoding7267_18; - operand.values[19] = tokenCoding7267_19; + operand.values[16] = tokenCoding7273_16; + operand.values[17] = tokenCoding7273_17; + operand.values[18] = tokenCoding7273_18; + operand.values[19] = tokenCoding7273_19; } -x64Token x64Parser::tokenBranches7266[] = { - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282 }, +x64Token x64Parser::tokenBranches7272[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7273, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7288 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7265[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, +x64Token x64Parser::tokenBranches7271[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7272 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7271_18[] = { +Coding x64Parser::tokenCoding7277_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7271_19[] = { +Coding x64Parser::tokenCoding7277_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7277(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -29828,22 +29897,22 @@ void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7271_18; - operand.values[19] = tokenCoding7271_19; + operand.values[18] = tokenCoding7277_18; + operand.values[19] = tokenCoding7277_19; } -x64Token x64Parser::tokenBranches7270[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7271, }, +x64Token x64Parser::tokenBranches7276[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7277, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7269[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270 }, +x64Token x64Parser::tokenBranches7275[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7276 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7268[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269 }, +x64Token x64Parser::tokenBranches7274[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7275 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) { operand.values[30] = new Coding[2]; CleanupValues.push_back(operand.values[30]); @@ -29855,7 +29924,7 @@ void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) operand.values[30]->binary = 0; operand.values[30][1].type = Coding::eot; } -void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6985(x64Operand &operand, int tokenPos) { operand.values[31] = new Coding[2]; CleanupValues.push_back(operand.values[31]); @@ -29867,7 +29936,7 @@ void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) operand.values[31]->binary = 0; operand.values[31][1].type = Coding::eot; } -void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6988(x64Operand &operand, int tokenPos) { operand.values[32] = new Coding[2]; CleanupValues.push_back(operand.values[32]); @@ -29879,7 +29948,7 @@ void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) operand.values[32]->binary = 0; operand.values[32][1].type = Coding::eot; } -void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7075(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29891,7 +29960,7 @@ void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7079(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29903,7 +29972,7 @@ void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7083(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29915,7 +29984,7 @@ void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7087(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29927,7 +29996,7 @@ void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7091(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29939,7 +30008,7 @@ void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29951,66 +30020,66 @@ void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6975[] = { - {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6976, x64Parser::tokenBranches6976 }, - {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6979, x64Parser::tokenBranches6979 }, - {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7069, x64Parser::tokenBranches7069 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7077, x64Parser::tokenBranches7077 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7081, x64Parser::tokenBranches7081 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7085, x64Parser::tokenBranches7085 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124 }, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7242, x64Parser::tokenBranches7242 }, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7297(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6981[] = { + {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, + {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6985, x64Parser::tokenBranches6985 }, + {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6988, x64Parser::tokenBranches6988 }, + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6991 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7019 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7047 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7075, x64Parser::tokenBranches7075 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7079, x64Parser::tokenBranches7079 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7083, x64Parser::tokenBranches7083 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7087, x64Parser::tokenBranches7087 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7091, x64Parser::tokenBranches7091 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7135 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7144 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7172 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7200 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7248, x64Parser::tokenBranches7248 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7271 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7274 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7303(x64Operand &operand, int tokenPos) { - operand.operandCoding = 606; + operand.operandCoding = 607; } -x64Token x64Parser::tokenBranches7296[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7297, }, +x64Token x64Parser::tokenBranches7302[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7303, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7295[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, +x64Token x64Parser::tokenBranches7301[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7302 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7294[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, +x64Token x64Parser::tokenBranches7300[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7301 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7310(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7316(x64Operand &operand, int tokenPos) { - operand.operandCoding = 607; + operand.operandCoding = 608; } -x64Token x64Parser::tokenBranches7309[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7310, }, +x64Token x64Parser::tokenBranches7315[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7316, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7308[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309 }, +x64Token x64Parser::tokenBranches7314[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7307[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308 }, +x64Token x64Parser::tokenBranches7313[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7314 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7313(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30022,60 +30091,60 @@ void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7293[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7307, x64Parser::tokenBranches7307 }, +x64Token x64Parser::tokenBranches7299[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7300 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7313, x64Parser::tokenBranches7313 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7292[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, +x64Token x64Parser::tokenBranches7298[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7299 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7291[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, +x64Token x64Parser::tokenBranches7297[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7298 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7290[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, +x64Token x64Parser::tokenBranches7296[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7297 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7289[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290 }, +x64Token x64Parser::tokenBranches7295[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7323(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7329(x64Operand &operand, int tokenPos) { - operand.operandCoding = 608; + operand.operandCoding = 609; } -x64Token x64Parser::tokenBranches7322[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7323, }, +x64Token x64Parser::tokenBranches7328[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7329, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7321[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, +x64Token x64Parser::tokenBranches7327[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7328 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7320[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, +x64Token x64Parser::tokenBranches7326[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7327 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7336(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7342(x64Operand &operand, int tokenPos) { - operand.operandCoding = 609; + operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches7335[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7336, }, +x64Token x64Parser::tokenBranches7341[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7342, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7334[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335 }, +x64Token x64Parser::tokenBranches7340[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7333[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334 }, +x64Token x64Parser::tokenBranches7339[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7339(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30087,65 +30156,65 @@ void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7319[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7333, x64Parser::tokenBranches7333 }, +x64Token x64Parser::tokenBranches7325[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7326 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7339, x64Parser::tokenBranches7339 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7318[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319 }, +x64Token x64Parser::tokenBranches7324[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7325 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7317[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318 }, +x64Token x64Parser::tokenBranches7323[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7324 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7316[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317 }, +x64Token x64Parser::tokenBranches7322[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7323 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7315[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316 }, +x64Token x64Parser::tokenBranches7321[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7288[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, +x64Token x64Parser::tokenBranches7294[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7287[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288 }, +x64Token x64Parser::tokenBranches7293[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7286[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287 }, +x64Token x64Parser::tokenBranches7292[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7345(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7351(x64Operand &operand, int tokenPos) { - operand.operandCoding = 610; + operand.operandCoding = 611; } -x64Token x64Parser::tokenBranches7344[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7345, }, +x64Token x64Parser::tokenBranches7350[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7351, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7356(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7362(x64Operand &operand, int tokenPos) { - operand.operandCoding = 611; + operand.operandCoding = 612; } -x64Token x64Parser::tokenBranches7355[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7356, }, +x64Token x64Parser::tokenBranches7361[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7362, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7354[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355 }, +x64Token x64Parser::tokenBranches7360[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7353[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354 }, +x64Token x64Parser::tokenBranches7359[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7359(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30157,69 +30226,69 @@ void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7343[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7353, x64Parser::tokenBranches7353 }, +x64Token x64Parser::tokenBranches7349[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7350 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7359, x64Parser::tokenBranches7359 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7342[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343 }, +x64Token x64Parser::tokenBranches7348[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7349 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7341[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342 }, +x64Token x64Parser::tokenBranches7347[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7348 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7340[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, +x64Token x64Parser::tokenBranches7346[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7347 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7339[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, +x64Token x64Parser::tokenBranches7345[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7346 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7338[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339 }, +x64Token x64Parser::tokenBranches7344[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7345 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7285[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338 }, +x64Token x64Parser::tokenBranches7291[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7369(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7375(x64Operand &operand, int tokenPos) { - operand.operandCoding = 612; + operand.operandCoding = 613; } -x64Token x64Parser::tokenBranches7368[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7369, }, +x64Token x64Parser::tokenBranches7374[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7375, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7367[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, +x64Token x64Parser::tokenBranches7373[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7374 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7366[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, +x64Token x64Parser::tokenBranches7372[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7373 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7382(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7388(x64Operand &operand, int tokenPos) { - operand.operandCoding = 613; + operand.operandCoding = 614; } -x64Token x64Parser::tokenBranches7381[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7382, }, +x64Token x64Parser::tokenBranches7387[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7388, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7380[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381 }, +x64Token x64Parser::tokenBranches7386[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7379[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380 }, +x64Token x64Parser::tokenBranches7385[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7386 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7385(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30231,60 +30300,60 @@ void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7365[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7379, x64Parser::tokenBranches7379 }, +x64Token x64Parser::tokenBranches7371[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7372 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7385, x64Parser::tokenBranches7385 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7364[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, +x64Token x64Parser::tokenBranches7370[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7371 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7363[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, +x64Token x64Parser::tokenBranches7369[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7370 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7362[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, +x64Token x64Parser::tokenBranches7368[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7369 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7361[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362 }, +x64Token x64Parser::tokenBranches7367[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7395(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7401(x64Operand &operand, int tokenPos) { - operand.operandCoding = 614; + operand.operandCoding = 615; } -x64Token x64Parser::tokenBranches7394[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7395, }, +x64Token x64Parser::tokenBranches7400[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7401, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7393[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, +x64Token x64Parser::tokenBranches7399[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7400 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7392[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, +x64Token x64Parser::tokenBranches7398[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7399 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7408(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7414(x64Operand &operand, int tokenPos) { - operand.operandCoding = 615; + operand.operandCoding = 616; } -x64Token x64Parser::tokenBranches7407[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7408, }, +x64Token x64Parser::tokenBranches7413[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7414, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7406[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407 }, +x64Token x64Parser::tokenBranches7412[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7405[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406 }, +x64Token x64Parser::tokenBranches7411[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7411(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30296,65 +30365,65 @@ void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7391[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7405, x64Parser::tokenBranches7405 }, +x64Token x64Parser::tokenBranches7397[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7398 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7411, x64Parser::tokenBranches7411 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7390[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391 }, +x64Token x64Parser::tokenBranches7396[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7397 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7389[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390 }, +x64Token x64Parser::tokenBranches7395[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7396 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7388[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389 }, +x64Token x64Parser::tokenBranches7394[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7395 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7387[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388 }, +x64Token x64Parser::tokenBranches7393[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7360[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, +x64Token x64Parser::tokenBranches7366[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7359[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, +x64Token x64Parser::tokenBranches7365[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7358[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359 }, +x64Token x64Parser::tokenBranches7364[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7417(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7423(x64Operand &operand, int tokenPos) { - operand.operandCoding = 616; + operand.operandCoding = 617; } -x64Token x64Parser::tokenBranches7416[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7417, }, +x64Token x64Parser::tokenBranches7422[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7423, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7428(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7434(x64Operand &operand, int tokenPos) { - operand.operandCoding = 617; + operand.operandCoding = 618; } -x64Token x64Parser::tokenBranches7427[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7428, }, +x64Token x64Parser::tokenBranches7433[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7434, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7426[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427 }, +x64Token x64Parser::tokenBranches7432[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7425[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426 }, +x64Token x64Parser::tokenBranches7431[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7431(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30366,69 +30435,69 @@ void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7415[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7425, x64Parser::tokenBranches7425 }, +x64Token x64Parser::tokenBranches7421[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7422 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7431, x64Parser::tokenBranches7431 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7414[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415 }, +x64Token x64Parser::tokenBranches7420[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7421 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7413[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414 }, +x64Token x64Parser::tokenBranches7419[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7420 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7412[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, +x64Token x64Parser::tokenBranches7418[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7419 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7411[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, +x64Token x64Parser::tokenBranches7417[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7418 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7410[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411 }, +x64Token x64Parser::tokenBranches7416[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7417 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7357[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410 }, +x64Token x64Parser::tokenBranches7363[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7441(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7447(x64Operand &operand, int tokenPos) { - operand.operandCoding = 618; + operand.operandCoding = 619; } -x64Token x64Parser::tokenBranches7440[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7441, }, +x64Token x64Parser::tokenBranches7446[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7447, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7439[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, +x64Token x64Parser::tokenBranches7445[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7446 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7438[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, +x64Token x64Parser::tokenBranches7444[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7445 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7454(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7460(x64Operand &operand, int tokenPos) { - operand.operandCoding = 619; + operand.operandCoding = 620; } -x64Token x64Parser::tokenBranches7453[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7454, }, +x64Token x64Parser::tokenBranches7459[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7460, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7452[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453 }, +x64Token x64Parser::tokenBranches7458[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7451[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452 }, +x64Token x64Parser::tokenBranches7457[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7458 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7457(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30440,60 +30509,60 @@ void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7437[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7451, x64Parser::tokenBranches7451 }, +x64Token x64Parser::tokenBranches7443[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7444 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7457, x64Parser::tokenBranches7457 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7436[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, +x64Token x64Parser::tokenBranches7442[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7443 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7435[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, +x64Token x64Parser::tokenBranches7441[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7442 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7434[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, +x64Token x64Parser::tokenBranches7440[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7441 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7433[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434 }, +x64Token x64Parser::tokenBranches7439[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7467(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7473(x64Operand &operand, int tokenPos) { - operand.operandCoding = 620; + operand.operandCoding = 621; } -x64Token x64Parser::tokenBranches7466[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7467, }, +x64Token x64Parser::tokenBranches7472[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7473, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7465[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, +x64Token x64Parser::tokenBranches7471[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7472 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7464[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, +x64Token x64Parser::tokenBranches7470[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7471 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7480(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7486(x64Operand &operand, int tokenPos) { - operand.operandCoding = 621; + operand.operandCoding = 622; } -x64Token x64Parser::tokenBranches7479[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7480, }, +x64Token x64Parser::tokenBranches7485[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7486, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7478[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479 }, +x64Token x64Parser::tokenBranches7484[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7477[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478 }, +x64Token x64Parser::tokenBranches7483[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7483(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30505,65 +30574,65 @@ void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7463[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7477, x64Parser::tokenBranches7477 }, +x64Token x64Parser::tokenBranches7469[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7470 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7483, x64Parser::tokenBranches7483 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7462[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463 }, +x64Token x64Parser::tokenBranches7468[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7469 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7461[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462 }, +x64Token x64Parser::tokenBranches7467[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7468 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7460[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461 }, +x64Token x64Parser::tokenBranches7466[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7467 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7459[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460 }, +x64Token x64Parser::tokenBranches7465[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7432[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, +x64Token x64Parser::tokenBranches7438[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7431[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, +x64Token x64Parser::tokenBranches7437[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7430[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431 }, +x64Token x64Parser::tokenBranches7436[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7489(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7495(x64Operand &operand, int tokenPos) { - operand.operandCoding = 622; + operand.operandCoding = 623; } -x64Token x64Parser::tokenBranches7488[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7489, }, +x64Token x64Parser::tokenBranches7494[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7495, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7500(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7506(x64Operand &operand, int tokenPos) { - operand.operandCoding = 623; + operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7499[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7500, }, +x64Token x64Parser::tokenBranches7505[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7506, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7498[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499 }, +x64Token x64Parser::tokenBranches7504[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7497[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498 }, +x64Token x64Parser::tokenBranches7503[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7503(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30575,69 +30644,69 @@ void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7487[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7497, x64Parser::tokenBranches7497 }, +x64Token x64Parser::tokenBranches7493[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7494 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7503, x64Parser::tokenBranches7503 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7486[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487 }, +x64Token x64Parser::tokenBranches7492[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7493 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7485[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486 }, +x64Token x64Parser::tokenBranches7491[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7492 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7484[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, +x64Token x64Parser::tokenBranches7490[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7491 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7483[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, +x64Token x64Parser::tokenBranches7489[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7490 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7482[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483 }, +x64Token x64Parser::tokenBranches7488[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7489 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7429[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482 }, +x64Token x64Parser::tokenBranches7435[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7513(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7519(x64Operand &operand, int tokenPos) { - operand.operandCoding = 624; + operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7512[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7513, }, +x64Token x64Parser::tokenBranches7518[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7519, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7511[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, +x64Token x64Parser::tokenBranches7517[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7518 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7510[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, +x64Token x64Parser::tokenBranches7516[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7517 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7526(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7532(x64Operand &operand, int tokenPos) { - operand.operandCoding = 625; + operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7525[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7526, }, +x64Token x64Parser::tokenBranches7531[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7532, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7524[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525 }, +x64Token x64Parser::tokenBranches7530[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7523[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524 }, +x64Token x64Parser::tokenBranches7529[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7529(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30649,64 +30718,64 @@ void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7509[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7523, x64Parser::tokenBranches7523 }, +x64Token x64Parser::tokenBranches7515[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7516 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7529, x64Parser::tokenBranches7529 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7508[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, +x64Token x64Parser::tokenBranches7514[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7515 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7507[] = { - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, +x64Token x64Parser::tokenBranches7513[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7514 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7506[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, +x64Token x64Parser::tokenBranches7512[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7513 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7505[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506 }, +x64Token x64Parser::tokenBranches7511[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7504[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, +x64Token x64Parser::tokenBranches7510[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7503[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, +x64Token x64Parser::tokenBranches7509[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7502[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503 }, +x64Token x64Parser::tokenBranches7508[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7535(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7541(x64Operand &operand, int tokenPos) { - operand.operandCoding = 624; + operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7534[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7535, }, +x64Token x64Parser::tokenBranches7540[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7541, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7546(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) { - operand.operandCoding = 625; + operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7545[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7546, }, +x64Token x64Parser::tokenBranches7551[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7552, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7544[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545 }, +x64Token x64Parser::tokenBranches7550[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7551 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7543[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544 }, +x64Token x64Parser::tokenBranches7549[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7550 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7549(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30718,170 +30787,170 @@ void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7533[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7543, x64Parser::tokenBranches7543 }, +x64Token x64Parser::tokenBranches7539[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7540 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7549, x64Parser::tokenBranches7549 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7532[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533 }, +x64Token x64Parser::tokenBranches7538[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7539 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7531[] = { - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532 }, +x64Token x64Parser::tokenBranches7537[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7538 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7530[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, +x64Token x64Parser::tokenBranches7536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7537 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7529[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, +x64Token x64Parser::tokenBranches7535[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7536 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7528[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529 }, +x64Token x64Parser::tokenBranches7534[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7535 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7501[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528 }, +x64Token x64Parser::tokenBranches7507[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7284[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501 }, +x64Token x64Parser::tokenBranches7290[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_16[] = { +Coding x64Parser::tokenCoding7557_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_17[] = { +Coding x64Parser::tokenCoding7557_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_18[] = { +Coding x64Parser::tokenCoding7557_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_19[] = { +Coding x64Parser::tokenCoding7557_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7551(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7557(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7551_16; - operand.values[17] = tokenCoding7551_17; - operand.values[18] = tokenCoding7551_18; - operand.values[19] = tokenCoding7551_19; + operand.values[16] = tokenCoding7557_16; + operand.values[17] = tokenCoding7557_17; + operand.values[18] = tokenCoding7557_18; + operand.values[19] = tokenCoding7557_19; } -x64Token x64Parser::tokenBranches7550[] = { - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7551, }, +x64Token x64Parser::tokenBranches7556[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7557, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7549[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550 }, +x64Token x64Parser::tokenBranches7555[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7556 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7548[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549 }, +x64Token x64Parser::tokenBranches7554[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7555 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_16[] = { +Coding x64Parser::tokenCoding7561_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_17[] = { +Coding x64Parser::tokenCoding7561_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_18[] = { +Coding x64Parser::tokenCoding7561_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_19[] = { +Coding x64Parser::tokenCoding7561_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7555(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7561(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7555_16; - operand.values[17] = tokenCoding7555_17; - operand.values[18] = tokenCoding7555_18; - operand.values[19] = tokenCoding7555_19; + operand.values[16] = tokenCoding7561_16; + operand.values[17] = tokenCoding7561_17; + operand.values[18] = tokenCoding7561_18; + operand.values[19] = tokenCoding7561_19; } -x64Token x64Parser::tokenBranches7554[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7555, }, +x64Token x64Parser::tokenBranches7560[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7561, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7553[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554 }, +x64Token x64Parser::tokenBranches7559[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7552[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553 }, +x64Token x64Parser::tokenBranches7558[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7559 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_16[] = { +Coding x64Parser::tokenCoding7565_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_17[] = { +Coding x64Parser::tokenCoding7565_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_18[] = { +Coding x64Parser::tokenCoding7565_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_19[] = { +Coding x64Parser::tokenCoding7565_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7559(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7565(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7559_16; - operand.values[17] = tokenCoding7559_17; - operand.values[18] = tokenCoding7559_18; - operand.values[19] = tokenCoding7559_19; + operand.values[16] = tokenCoding7565_16; + operand.values[17] = tokenCoding7565_17; + operand.values[18] = tokenCoding7565_18; + operand.values[19] = tokenCoding7565_19; } -x64Token x64Parser::tokenBranches7558[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7559, }, +x64Token x64Parser::tokenBranches7564[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7565, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7557[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558 }, +x64Token x64Parser::tokenBranches7563[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7556[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557 }, +x64Token x64Parser::tokenBranches7562[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7563 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_16[] = { +Coding x64Parser::tokenCoding7569_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_17[] = { +Coding x64Parser::tokenCoding7569_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_18[] = { +Coding x64Parser::tokenCoding7569_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_19[] = { +Coding x64Parser::tokenCoding7569_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7569(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30892,42 +30961,42 @@ void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7563_16; - operand.values[17] = tokenCoding7563_17; - operand.values[18] = tokenCoding7563_18; - operand.values[19] = tokenCoding7563_19; + operand.values[16] = tokenCoding7569_16; + operand.values[17] = tokenCoding7569_17; + operand.values[18] = tokenCoding7569_18; + operand.values[19] = tokenCoding7569_19; } -x64Token x64Parser::tokenBranches7562[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7563, }, +x64Token x64Parser::tokenBranches7568[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7569, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7561[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562 }, +x64Token x64Parser::tokenBranches7567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7568 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7560[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561 }, +x64Token x64Parser::tokenBranches7566[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7567 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_16[] = { +Coding x64Parser::tokenCoding7573_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_17[] = { +Coding x64Parser::tokenCoding7573_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_18[] = { +Coding x64Parser::tokenCoding7573_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_19[] = { +Coding x64Parser::tokenCoding7573_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7573(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30938,42 +31007,42 @@ void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7567_16; - operand.values[17] = tokenCoding7567_17; - operand.values[18] = tokenCoding7567_18; - operand.values[19] = tokenCoding7567_19; + operand.values[16] = tokenCoding7573_16; + operand.values[17] = tokenCoding7573_17; + operand.values[18] = tokenCoding7573_18; + operand.values[19] = tokenCoding7573_19; } -x64Token x64Parser::tokenBranches7566[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7567, }, +x64Token x64Parser::tokenBranches7572[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7573, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7565[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566 }, +x64Token x64Parser::tokenBranches7571[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7572 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7564[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565 }, +x64Token x64Parser::tokenBranches7570[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7571 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_16[] = { +Coding x64Parser::tokenCoding7577_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_17[] = { +Coding x64Parser::tokenCoding7577_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_18[] = { +Coding x64Parser::tokenCoding7577_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_19[] = { +Coding x64Parser::tokenCoding7577_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30984,24 +31053,24 @@ void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7571_16; - operand.values[17] = tokenCoding7571_17; - operand.values[18] = tokenCoding7571_18; - operand.values[19] = tokenCoding7571_19; + operand.values[16] = tokenCoding7577_16; + operand.values[17] = tokenCoding7577_17; + operand.values[18] = tokenCoding7577_18; + operand.values[19] = tokenCoding7577_19; } -x64Token x64Parser::tokenBranches7570[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7571, }, +x64Token x64Parser::tokenBranches7576[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7577, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7569[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570 }, +x64Token x64Parser::tokenBranches7575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7568[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569 }, +x64Token x64Parser::tokenBranches7574[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7575 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7554(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31013,7 +31082,7 @@ void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7558(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31025,7 +31094,7 @@ void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7562(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31037,74 +31106,74 @@ void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7547[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7548, x64Parser::tokenBranches7548 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7552, x64Parser::tokenBranches7552 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7556, x64Parser::tokenBranches7556 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568 }, +x64Token x64Parser::tokenBranches7553[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7554, x64Parser::tokenBranches7554 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7558, x64Parser::tokenBranches7558 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7562, x64Parser::tokenBranches7562 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7566 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7570 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7574 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_16[] = { +Coding x64Parser::tokenCoding7583_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_17[] = { +Coding x64Parser::tokenCoding7583_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_23[] = { +Coding x64Parser::tokenCoding7583_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_18[] = { +Coding x64Parser::tokenCoding7583_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_19[] = { +Coding x64Parser::tokenCoding7583_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7577_16; - operand.values[17] = tokenCoding7577_17; - operand.values[23] = tokenCoding7577_23; - operand.values[18] = tokenCoding7577_18; - operand.values[19] = tokenCoding7577_19; + operand.values[16] = tokenCoding7583_16; + operand.values[17] = tokenCoding7583_17; + operand.values[23] = tokenCoding7583_23; + operand.values[18] = tokenCoding7583_18; + operand.values[19] = tokenCoding7583_19; } -x64Token x64Parser::tokenBranches7576[] = { - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7577, }, +x64Token x64Parser::tokenBranches7582[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7583, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7575[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, +x64Token x64Parser::tokenBranches7581[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7582 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_16[] = { +Coding x64Parser::tokenCoding7586_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_17[] = { +Coding x64Parser::tokenCoding7586_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_23[] = { +Coding x64Parser::tokenCoding7586_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_18[] = { +Coding x64Parser::tokenCoding7586_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_19[] = { +Coding x64Parser::tokenCoding7586_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7586(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31115,21 +31184,21 @@ void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7580_16; - operand.values[17] = tokenCoding7580_17; - operand.values[23] = tokenCoding7580_23; - operand.values[18] = tokenCoding7580_18; - operand.values[19] = tokenCoding7580_19; + operand.values[16] = tokenCoding7586_16; + operand.values[17] = tokenCoding7586_17; + operand.values[23] = tokenCoding7586_23; + operand.values[18] = tokenCoding7586_18; + operand.values[19] = tokenCoding7586_19; } -x64Token x64Parser::tokenBranches7579[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7580, }, +x64Token x64Parser::tokenBranches7585[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7586, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7578[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579 }, +x64Token x64Parser::tokenBranches7584[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7585 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31141,147 +31210,147 @@ void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) { - operand.operandCoding = 626; + operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches7574[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7575, x64Parser::tokenBranches7575 }, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578 }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7581, }, +x64Token x64Parser::tokenBranches7580[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7581, x64Parser::tokenBranches7581 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7584 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7587, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) { - operand.operandCoding = 627; + operand.operandCoding = 628; } -x64Token x64Parser::tokenBranches7582[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7583, }, +x64Token x64Parser::tokenBranches7588[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7589, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_16[] = { +Coding x64Parser::tokenCoding7599_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_17[] = { +Coding x64Parser::tokenCoding7599_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_18[] = { +Coding x64Parser::tokenCoding7599_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_19[] = { +Coding x64Parser::tokenCoding7599_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7599(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7593_16; - operand.values[17] = tokenCoding7593_17; - operand.values[18] = tokenCoding7593_18; - operand.values[19] = tokenCoding7593_19; + operand.values[16] = tokenCoding7599_16; + operand.values[17] = tokenCoding7599_17; + operand.values[18] = tokenCoding7599_18; + operand.values[19] = tokenCoding7599_19; } -x64Token x64Parser::tokenBranches7592[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7593, }, +x64Token x64Parser::tokenBranches7598[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7599, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_16[] = { +Coding x64Parser::tokenCoding7595_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_17[] = { +Coding x64Parser::tokenCoding7595_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_18[] = { +Coding x64Parser::tokenCoding7595_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_19[] = { +Coding x64Parser::tokenCoding7595_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7595(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7589_16; - operand.values[17] = tokenCoding7589_17; - operand.values[18] = tokenCoding7589_18; - operand.values[19] = tokenCoding7589_19; + operand.values[16] = tokenCoding7595_16; + operand.values[17] = tokenCoding7595_17; + operand.values[18] = tokenCoding7595_18; + operand.values[19] = tokenCoding7595_19; } -x64Token x64Parser::tokenBranches7588[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7589, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592 }, +x64Token x64Parser::tokenBranches7594[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7595, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7598 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7587[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588 }, +x64Token x64Parser::tokenBranches7593[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7594 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_16[] = { +Coding x64Parser::tokenCoding7606_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_17[] = { +Coding x64Parser::tokenCoding7606_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_18[] = { +Coding x64Parser::tokenCoding7606_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_19[] = { +Coding x64Parser::tokenCoding7606_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7606(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7600_16; - operand.values[17] = tokenCoding7600_17; - operand.values[18] = tokenCoding7600_18; - operand.values[19] = tokenCoding7600_19; + operand.values[16] = tokenCoding7606_16; + operand.values[17] = tokenCoding7606_17; + operand.values[18] = tokenCoding7606_18; + operand.values[19] = tokenCoding7606_19; } -x64Token x64Parser::tokenBranches7599[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7600, }, +x64Token x64Parser::tokenBranches7605[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7606, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7596_16[] = { +Coding x64Parser::tokenCoding7602_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_17[] = { +Coding x64Parser::tokenCoding7602_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_18[] = { +Coding x64Parser::tokenCoding7602_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_19[] = { +Coding x64Parser::tokenCoding7602_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7596(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7602(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7596_16; - operand.values[17] = tokenCoding7596_17; - operand.values[18] = tokenCoding7596_18; - operand.values[19] = tokenCoding7596_19; + operand.values[16] = tokenCoding7602_16; + operand.values[17] = tokenCoding7602_17; + operand.values[18] = tokenCoding7602_18; + operand.values[19] = tokenCoding7602_19; } -x64Token x64Parser::tokenBranches7595[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7596, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599 }, +x64Token x64Parser::tokenBranches7601[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7602, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7605 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7594[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595 }, +x64Token x64Parser::tokenBranches7600[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7601 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31293,7 +31362,7 @@ void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31305,24 +31374,24 @@ void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7586[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7587, x64Parser::tokenBranches7587 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7594, x64Parser::tokenBranches7594 }, +x64Token x64Parser::tokenBranches7592[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7593, x64Parser::tokenBranches7593 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7600, x64Parser::tokenBranches7600 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7610(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) { - operand.operandCoding = 628; + operand.operandCoding = 629; } -x64Token x64Parser::tokenBranches7609[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7610, }, +x64Token x64Parser::tokenBranches7615[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7616, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7608[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609 }, +x64Token x64Parser::tokenBranches7614[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7615 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31335,23 +31404,23 @@ void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7607[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7608, x64Parser::tokenBranches7608 }, +x64Token x64Parser::tokenBranches7613[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7614, x64Parser::tokenBranches7614 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) { - operand.operandCoding = 629; + operand.operandCoding = 630; } -x64Token x64Parser::tokenBranches7613[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7614, }, +x64Token x64Parser::tokenBranches7619[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7620, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7612[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613 }, +x64Token x64Parser::tokenBranches7618[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7619 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31364,23 +31433,23 @@ void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7611[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7612, x64Parser::tokenBranches7612 }, +x64Token x64Parser::tokenBranches7617[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7618, x64Parser::tokenBranches7618 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7624(x64Operand &operand, int tokenPos) { - operand.operandCoding = 630; + operand.operandCoding = 631; } -x64Token x64Parser::tokenBranches7617[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7618, }, +x64Token x64Parser::tokenBranches7623[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7624, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7616[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617 }, +x64Token x64Parser::tokenBranches7622[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31393,23 +31462,23 @@ void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7615[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7616, x64Parser::tokenBranches7616 }, +x64Token x64Parser::tokenBranches7621[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7622, x64Parser::tokenBranches7622 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) { - operand.operandCoding = 631; + operand.operandCoding = 632; } -x64Token x64Parser::tokenBranches7621[] = { - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7622, }, +x64Token x64Parser::tokenBranches7627[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7628, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7620[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621 }, +x64Token x64Parser::tokenBranches7626[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7627 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7626(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31422,113 +31491,113 @@ void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7619[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7620, x64Parser::tokenBranches7620 }, +x64Token x64Parser::tokenBranches7625[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7626, x64Parser::tokenBranches7626 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7625(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 632; -} -void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) { operand.operandCoding = 633; } -void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) { operand.operandCoding = 634; } -void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7637(x64Operand &operand, int tokenPos) { operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches7624[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7625, }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7628, }, - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7631, }, - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7634, }, +void x64Parser::TokenFunc7640(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 636; +} +x64Token x64Parser::tokenBranches7630[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7631, }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7634, }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7637, }, + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7640, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7623[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624 }, +x64Token x64Parser::tokenBranches7629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7630 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7606[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619 }, - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, +x64Token x64Parser::tokenBranches7612[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7613 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7617 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7621 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7625 }, + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7629 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7643(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7649(x64Operand &operand, int tokenPos) { - operand.operandCoding = 636; + operand.operandCoding = 637; } -x64Token x64Parser::tokenBranches7642[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7643, }, +x64Token x64Parser::tokenBranches7648[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7649, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7659(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7665(x64Operand &operand, int tokenPos) { - operand.operandCoding = 638; + operand.operandCoding = 639; } -x64Token x64Parser::tokenBranches7658[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7659, }, +x64Token x64Parser::tokenBranches7664[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7665, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7641[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658 }, +x64Token x64Parser::tokenBranches7647[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7648 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7664 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7640[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641 }, +x64Token x64Parser::tokenBranches7646[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7647 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7651(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7657(x64Operand &operand, int tokenPos) { - operand.operandCoding = 637; + operand.operandCoding = 638; } -x64Token x64Parser::tokenBranches7650[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7651, }, +x64Token x64Parser::tokenBranches7656[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7657, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7667(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) { - operand.operandCoding = 639; + operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches7666[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7667, }, +x64Token x64Parser::tokenBranches7672[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7681(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7687(x64Operand &operand, int tokenPos) { - operand.operandCoding = 641; + operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7680[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7681, }, +x64Token x64Parser::tokenBranches7686[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7687, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7649[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680 }, +x64Token x64Parser::tokenBranches7655[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7656 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7648[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649 }, +x64Token x64Parser::tokenBranches7654[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7655 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7679(x64Operand &operand, int tokenPos) { - operand.operandCoding = 640; + operand.operandCoding = 641; } -x64Token x64Parser::tokenBranches7672[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, +x64Token x64Parser::tokenBranches7678[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7679, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7654(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31540,84 +31609,84 @@ void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7639[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7648, x64Parser::tokenBranches7648 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, +x64Token x64Parser::tokenBranches7645[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7646 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7654, x64Parser::tokenBranches7654 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7678 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7638[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639 }, +x64Token x64Parser::tokenBranches7644[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7645 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7689(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7695(x64Operand &operand, int tokenPos) { - operand.operandCoding = 642; + operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7688[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7689, }, +x64Token x64Parser::tokenBranches7694[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7695, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7705(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7711(x64Operand &operand, int tokenPos) { - operand.operandCoding = 644; + operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7704[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7705, }, +x64Token x64Parser::tokenBranches7710[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7711, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7687[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704 }, +x64Token x64Parser::tokenBranches7693[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7694 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7710 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7686[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687 }, +x64Token x64Parser::tokenBranches7692[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7693 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7697(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7703(x64Operand &operand, int tokenPos) { - operand.operandCoding = 643; + operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7696[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7697, }, +x64Token x64Parser::tokenBranches7702[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7703, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7713(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) { - operand.operandCoding = 645; + operand.operandCoding = 646; } -x64Token x64Parser::tokenBranches7712[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7713, }, +x64Token x64Parser::tokenBranches7718[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7727(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7733(x64Operand &operand, int tokenPos) { - operand.operandCoding = 647; + operand.operandCoding = 648; } -x64Token x64Parser::tokenBranches7726[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7727, }, +x64Token x64Parser::tokenBranches7732[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7733, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7695[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726 }, +x64Token x64Parser::tokenBranches7701[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7702 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7694[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695 }, +x64Token x64Parser::tokenBranches7700[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7701 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7725(x64Operand &operand, int tokenPos) { - operand.operandCoding = 646; + operand.operandCoding = 647; } -x64Token x64Parser::tokenBranches7718[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, +x64Token x64Parser::tokenBranches7724[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7725, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7700(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31629,84 +31698,84 @@ void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7685[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7694, x64Parser::tokenBranches7694 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, +x64Token x64Parser::tokenBranches7691[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7692 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7700, x64Parser::tokenBranches7700 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7724 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7684[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685 }, +x64Token x64Parser::tokenBranches7690[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7691 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7735(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7741(x64Operand &operand, int tokenPos) { - operand.operandCoding = 648; + operand.operandCoding = 649; } -x64Token x64Parser::tokenBranches7734[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7735, }, +x64Token x64Parser::tokenBranches7740[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7741, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7751(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7757(x64Operand &operand, int tokenPos) { - operand.operandCoding = 650; + operand.operandCoding = 651; } -x64Token x64Parser::tokenBranches7750[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7751, }, +x64Token x64Parser::tokenBranches7756[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7757, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7733[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750 }, +x64Token x64Parser::tokenBranches7739[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7740 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7756 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7732[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733 }, +x64Token x64Parser::tokenBranches7738[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7739 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7743(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7749(x64Operand &operand, int tokenPos) { - operand.operandCoding = 649; + operand.operandCoding = 650; } -x64Token x64Parser::tokenBranches7742[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7743, }, +x64Token x64Parser::tokenBranches7748[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7749, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7759(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) { - operand.operandCoding = 651; + operand.operandCoding = 652; } -x64Token x64Parser::tokenBranches7758[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7759, }, +x64Token x64Parser::tokenBranches7764[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7773(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) { - operand.operandCoding = 653; + operand.operandCoding = 654; } -x64Token x64Parser::tokenBranches7772[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7773, }, +x64Token x64Parser::tokenBranches7778[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7779, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7741[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772 }, +x64Token x64Parser::tokenBranches7747[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7748 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7778 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7740[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741 }, +x64Token x64Parser::tokenBranches7746[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7747 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7771(x64Operand &operand, int tokenPos) { - operand.operandCoding = 652; + operand.operandCoding = 653; } -x64Token x64Parser::tokenBranches7764[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, +x64Token x64Parser::tokenBranches7770[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7771, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7746(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31718,117 +31787,117 @@ void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7731[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7740, x64Parser::tokenBranches7740 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, +x64Token x64Parser::tokenBranches7737[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7738 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7746, x64Parser::tokenBranches7746 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7770 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7730[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731 }, +x64Token x64Parser::tokenBranches7736[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7737 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7637[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730 }, +x64Token x64Parser::tokenBranches7643[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7644 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7690 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7736 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7636[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637 }, +x64Token x64Parser::tokenBranches7642[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7643 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7635[] = { - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636 }, +x64Token x64Parser::tokenBranches7641[] = { + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_16[] = { +Coding x64Parser::tokenCoding7788_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_17[] = { +Coding x64Parser::tokenCoding7788_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_18[] = { +Coding x64Parser::tokenCoding7788_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_19[] = { +Coding x64Parser::tokenCoding7788_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7782(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7782_16; - operand.values[17] = tokenCoding7782_17; - operand.values[18] = tokenCoding7782_18; - operand.values[19] = tokenCoding7782_19; + operand.values[16] = tokenCoding7788_16; + operand.values[17] = tokenCoding7788_17; + operand.values[18] = tokenCoding7788_18; + operand.values[19] = tokenCoding7788_19; } -x64Token x64Parser::tokenBranches7781[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7782, }, +x64Token x64Parser::tokenBranches7787[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7788, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_16[] = { +Coding x64Parser::tokenCoding7790_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_17[] = { +Coding x64Parser::tokenCoding7790_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_18[] = { +Coding x64Parser::tokenCoding7790_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_19[] = { +Coding x64Parser::tokenCoding7790_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7790(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7784_16; - operand.values[17] = tokenCoding7784_17; - operand.values[18] = tokenCoding7784_18; - operand.values[19] = tokenCoding7784_19; + operand.values[16] = tokenCoding7790_16; + operand.values[17] = tokenCoding7790_17; + operand.values[18] = tokenCoding7790_18; + operand.values[19] = tokenCoding7790_19; } -x64Token x64Parser::tokenBranches7783[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7784, }, +x64Token x64Parser::tokenBranches7789[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7790, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_16[] = { +Coding x64Parser::tokenCoding7792_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_17[] = { +Coding x64Parser::tokenCoding7792_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_18[] = { +Coding x64Parser::tokenCoding7792_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_19[] = { +Coding x64Parser::tokenCoding7792_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7792(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7786_16; - operand.values[17] = tokenCoding7786_17; - operand.values[18] = tokenCoding7786_18; - operand.values[19] = tokenCoding7786_19; + operand.values[16] = tokenCoding7792_16; + operand.values[17] = tokenCoding7792_17; + operand.values[18] = tokenCoding7792_18; + operand.values[19] = tokenCoding7792_19; } -x64Token x64Parser::tokenBranches7785[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7786, }, +x64Token x64Parser::tokenBranches7791[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7792, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) { - operand.operandCoding = 654; + operand.operandCoding = 655; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31839,9 +31908,9 @@ void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7785(x64Operand &operand, int tokenPos) { - operand.operandCoding = 655; + operand.operandCoding = 656; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31852,9 +31921,9 @@ void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) { - operand.operandCoding = 656; + operand.operandCoding = 657; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31865,17 +31934,17 @@ void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7787(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 657; -} -void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7793(x64Operand &operand, int tokenPos) { operand.operandCoding = 658; } -void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7794(x64Operand &operand, int tokenPos) { operand.operandCoding = 659; +} +void x64Parser::TokenFunc7795(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 660; operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); operand.values[2]->type = Coding::reg; @@ -31886,189 +31955,171 @@ void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7777[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7778, }, - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7779, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7780, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785 }, - {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7787, }, - {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7788, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7789, }, +x64Token x64Parser::tokenBranches7783[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7784, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7785, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7786, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7787 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7789 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7791 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7793, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7794, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7795, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_34[] = { +Coding x64Parser::tokenCoding7805_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_16[] = { +Coding x64Parser::tokenCoding7805_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_17[] = { +Coding x64Parser::tokenCoding7805_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_35[] = { +Coding x64Parser::tokenCoding7805_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_18[] = { +Coding x64Parser::tokenCoding7805_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_19[] = { +Coding x64Parser::tokenCoding7805_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7799(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7799_34; - operand.values[16] = tokenCoding7799_16; - operand.values[17] = tokenCoding7799_17; - operand.values[35] = tokenCoding7799_35; - operand.values[18] = tokenCoding7799_18; - operand.values[19] = tokenCoding7799_19; + operand.values[34] = tokenCoding7805_34; + operand.values[16] = tokenCoding7805_16; + operand.values[17] = tokenCoding7805_17; + operand.values[35] = tokenCoding7805_35; + operand.values[18] = tokenCoding7805_18; + operand.values[19] = tokenCoding7805_19; } -x64Token x64Parser::tokenBranches7798[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7799, }, +x64Token x64Parser::tokenBranches7804[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_34[] = { +Coding x64Parser::tokenCoding7807_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_16[] = { +Coding x64Parser::tokenCoding7807_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_17[] = { +Coding x64Parser::tokenCoding7807_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_35[] = { +Coding x64Parser::tokenCoding7807_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_18[] = { +Coding x64Parser::tokenCoding7807_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_19[] = { +Coding x64Parser::tokenCoding7807_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7801(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7801_34; - operand.values[16] = tokenCoding7801_16; - operand.values[17] = tokenCoding7801_17; - operand.values[35] = tokenCoding7801_35; - operand.values[18] = tokenCoding7801_18; - operand.values[19] = tokenCoding7801_19; + operand.values[34] = tokenCoding7807_34; + operand.values[16] = tokenCoding7807_16; + operand.values[17] = tokenCoding7807_17; + operand.values[35] = tokenCoding7807_35; + operand.values[18] = tokenCoding7807_18; + operand.values[19] = tokenCoding7807_19; } -x64Token x64Parser::tokenBranches7800[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7801, }, +x64Token x64Parser::tokenBranches7806[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7807, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_34[] = { +Coding x64Parser::tokenCoding7809_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_16[] = { +Coding x64Parser::tokenCoding7809_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_17[] = { +Coding x64Parser::tokenCoding7809_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_35[] = { +Coding x64Parser::tokenCoding7809_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_18[] = { +Coding x64Parser::tokenCoding7809_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_19[] = { +Coding x64Parser::tokenCoding7809_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7803(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7803_34; - operand.values[16] = tokenCoding7803_16; - operand.values[17] = tokenCoding7803_17; - operand.values[35] = tokenCoding7803_35; - operand.values[18] = tokenCoding7803_18; - operand.values[19] = tokenCoding7803_19; + operand.values[34] = tokenCoding7809_34; + operand.values[16] = tokenCoding7809_16; + operand.values[17] = tokenCoding7809_17; + operand.values[35] = tokenCoding7809_35; + operand.values[18] = tokenCoding7809_18; + operand.values[19] = tokenCoding7809_19; } -x64Token x64Parser::tokenBranches7802[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7803, }, +x64Token x64Parser::tokenBranches7808[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7809, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_34[] = { +Coding x64Parser::tokenCoding7811_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_16[] = { +Coding x64Parser::tokenCoding7811_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_17[] = { +Coding x64Parser::tokenCoding7811_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_35[] = { +Coding x64Parser::tokenCoding7811_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_18[] = { +Coding x64Parser::tokenCoding7811_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_19[] = { +Coding x64Parser::tokenCoding7811_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) -{ - operand.values[34] = tokenCoding7805_34; - operand.values[16] = tokenCoding7805_16; - operand.values[17] = tokenCoding7805_17; - operand.values[35] = tokenCoding7805_35; - operand.values[18] = tokenCoding7805_18; - operand.values[19] = tokenCoding7805_19; -} -x64Token x64Parser::tokenBranches7804[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, - {x64Token::EOT } -}; void x64Parser::TokenFunc7811(x64Operand &operand, int tokenPos) { - operand.operandCoding = 663; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); + operand.values[34] = tokenCoding7811_34; + operand.values[16] = tokenCoding7811_16; + operand.values[17] = tokenCoding7811_17; + operand.values[35] = tokenCoding7811_35; + operand.values[18] = tokenCoding7811_18; + operand.values[19] = tokenCoding7811_19; } x64Token x64Parser::tokenBranches7810[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7817(x64Operand &operand, int tokenPos) { operand.operandCoding = 664; operand.values[22] = new Coding[2]; @@ -32082,37 +32133,11 @@ void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7822_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 4 }, - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 667; - operand.values[16] = tokenCoding7822_16; - operand.values[17] = tokenCoding7822_17; - operand.values[18] = tokenCoding7822_18; - operand.values[19] = tokenCoding7822_19; -} -x64Token x64Parser::tokenBranches7815[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7816, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7822, }, +x64Token x64Parser::tokenBranches7816[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7817, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) { operand.operandCoding = 665; operand.values[22] = new Coding[2]; @@ -32126,37 +32151,37 @@ void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7824_16[] = { +Coding x64Parser::tokenCoding7828_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_17[] = { +Coding x64Parser::tokenCoding7828_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_18[] = { +Coding x64Parser::tokenCoding7828_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 5 }, +Coding x64Parser::tokenCoding7828_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) { operand.operandCoding = 668; - operand.values[16] = tokenCoding7824_16; - operand.values[17] = tokenCoding7824_17; - operand.values[18] = tokenCoding7824_18; - operand.values[19] = tokenCoding7824_19; + operand.values[16] = tokenCoding7828_16; + operand.values[17] = tokenCoding7828_17; + operand.values[18] = tokenCoding7828_18; + operand.values[19] = tokenCoding7828_19; } -x64Token x64Parser::tokenBranches7817[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7818, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7824, }, +x64Token x64Parser::tokenBranches7821[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7822, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7828, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) { operand.operandCoding = 666; operand.values[22] = new Coding[2]; @@ -32170,39 +32195,83 @@ void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7826_16[] = { +Coding x64Parser::tokenCoding7830_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_17[] = { +Coding x64Parser::tokenCoding7830_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_18[] = { +Coding x64Parser::tokenCoding7830_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 6 }, +Coding x64Parser::tokenCoding7830_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; +void x64Parser::TokenFunc7830(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; + operand.values[16] = tokenCoding7830_16; + operand.values[17] = tokenCoding7830_17; + operand.values[18] = tokenCoding7830_18; + operand.values[19] = tokenCoding7830_19; +} +x64Token x64Parser::tokenBranches7823[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7824, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7830, }, + {x64Token::EOT } +}; void x64Parser::TokenFunc7826(x64Operand &operand, int tokenPos) { - operand.operandCoding = 668; - operand.values[16] = tokenCoding7826_16; - operand.values[17] = tokenCoding7826_17; - operand.values[18] = tokenCoding7826_18; - operand.values[19] = tokenCoding7826_19; + operand.operandCoding = 667; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7819[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7820, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7826, }, +Coding x64Parser::tokenCoding7832_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7832(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; + operand.values[16] = tokenCoding7832_16; + operand.values[17] = tokenCoding7832_17; + operand.values[18] = tokenCoding7832_18; + operand.values[19] = tokenCoding7832_19; +} +x64Token x64Parser::tokenBranches7825[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7826, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7832, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) { - operand.operandCoding = 660; + operand.operandCoding = 661; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32213,9 +32282,9 @@ void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) { - operand.operandCoding = 661; + operand.operandCoding = 662; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32226,9 +32295,9 @@ void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7815(x64Operand &operand, int tokenPos) { - operand.operandCoding = 662; + operand.operandCoding = 663; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32239,9 +32308,9 @@ void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) { - operand.operandCoding = 664; + operand.operandCoding = 665; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32253,9 +32322,9 @@ void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7819(x64Operand &operand, int tokenPos) { - operand.operandCoding = 665; + operand.operandCoding = 666; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32267,9 +32336,9 @@ void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) { - operand.operandCoding = 666; + operand.operandCoding = 667; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32281,17 +32350,17 @@ void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7827(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 669; -} -void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7833(x64Operand &operand, int tokenPos) { operand.operandCoding = 670; } -void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7834(x64Operand &operand, int tokenPos) { operand.operandCoding = 671; +} +void x64Parser::TokenFunc7835(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 672; operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); operand.values[2]->type = Coding::reg; @@ -32302,25 +32371,25 @@ void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7806[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7807, }, - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7808, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7809, }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810 }, - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7812, }, - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7813, }, - {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7814, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819 }, - {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7827, }, - {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7828, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7829, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches7812[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7813, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7814, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7815, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7816 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7818, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7819, }, + {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7820, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7821 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7823 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7825 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7833, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7834, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7835, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7849(x64Operand &operand, int tokenPos) { - operand.operandCoding = 672; + operand.operandCoding = 673; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32332,18 +32401,18 @@ void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7844(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7850(x64Operand &operand, int tokenPos) { - operand.operandCoding = 673; + operand.operandCoding = 674; } -x64Token x64Parser::tokenBranches7842[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7843, }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7844, }, +x64Token x64Parser::tokenBranches7848[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7849, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7850, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7852(x64Operand &operand, int tokenPos) { - operand.operandCoding = 674; + operand.operandCoding = 675; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32355,87 +32424,87 @@ void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7847(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7853(x64Operand &operand, int tokenPos) { - operand.operandCoding = 675; + operand.operandCoding = 676; } -x64Token x64Parser::tokenBranches7845[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7846, }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7847, }, +x64Token x64Parser::tokenBranches7851[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7852, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7853, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7861(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) { - operand.operandCoding = 676; + operand.operandCoding = 677; } -x64Token x64Parser::tokenBranches7860[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7861, }, +x64Token x64Parser::tokenBranches7866[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) { - operand.operandCoding = 678; + operand.operandCoding = 679; } -x64Token x64Parser::tokenBranches7872[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, +x64Token x64Parser::tokenBranches7878[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7859[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, +x64Token x64Parser::tokenBranches7865[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7858[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859 }, +x64Token x64Parser::tokenBranches7864[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7857[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858 }, +x64Token x64Parser::tokenBranches7863[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7864 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) { - operand.operandCoding = 677; + operand.operandCoding = 678; } -x64Token x64Parser::tokenBranches7866[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, +x64Token x64Parser::tokenBranches7872[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7885(x64Operand &operand, int tokenPos) { - operand.operandCoding = 679; + operand.operandCoding = 680; } -x64Token x64Parser::tokenBranches7878[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, +x64Token x64Parser::tokenBranches7884[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7885, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) { - operand.operandCoding = 681; + operand.operandCoding = 682; } -x64Token x64Parser::tokenBranches7888[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, +x64Token x64Parser::tokenBranches7894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7865[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, +x64Token x64Parser::tokenBranches7871[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7884 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7864[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, +x64Token x64Parser::tokenBranches7870[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7871 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7883(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) { - operand.operandCoding = 680; + operand.operandCoding = 681; } -x64Token x64Parser::tokenBranches7882[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7883, }, +x64Token x64Parser::tokenBranches7888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7870(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32447,88 +32516,88 @@ void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7863[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7864, x64Parser::tokenBranches7864 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882 }, +x64Token x64Parser::tokenBranches7869[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7870, x64Parser::tokenBranches7870 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7856[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, +x64Token x64Parser::tokenBranches7862[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7869 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) { - operand.operandCoding = 682; + operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7894[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, +x64Token x64Parser::tokenBranches7900[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) { - operand.operandCoding = 684; + operand.operandCoding = 685; } -x64Token x64Parser::tokenBranches7906[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, +x64Token x64Parser::tokenBranches7912[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7893[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, +x64Token x64Parser::tokenBranches7899[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7892[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893 }, +x64Token x64Parser::tokenBranches7898[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7891[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892 }, +x64Token x64Parser::tokenBranches7897[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7898 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) { - operand.operandCoding = 683; + operand.operandCoding = 684; } -x64Token x64Parser::tokenBranches7900[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, +x64Token x64Parser::tokenBranches7906[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7919(x64Operand &operand, int tokenPos) { - operand.operandCoding = 685; + operand.operandCoding = 686; } -x64Token x64Parser::tokenBranches7912[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, +x64Token x64Parser::tokenBranches7918[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7919, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) { - operand.operandCoding = 687; + operand.operandCoding = 688; } -x64Token x64Parser::tokenBranches7922[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, +x64Token x64Parser::tokenBranches7928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7899[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, +x64Token x64Parser::tokenBranches7905[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7918 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7898[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, +x64Token x64Parser::tokenBranches7904[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7905 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7917(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) { - operand.operandCoding = 686; + operand.operandCoding = 687; } -x64Token x64Parser::tokenBranches7916[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7917, }, +x64Token x64Parser::tokenBranches7922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7904(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32540,88 +32609,88 @@ void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7897[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7898, x64Parser::tokenBranches7898 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916 }, +x64Token x64Parser::tokenBranches7903[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7904, x64Parser::tokenBranches7904 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7890[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, +x64Token x64Parser::tokenBranches7896[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7903 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) { - operand.operandCoding = 688; + operand.operandCoding = 689; } -x64Token x64Parser::tokenBranches7928[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, +x64Token x64Parser::tokenBranches7934[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) { - operand.operandCoding = 690; + operand.operandCoding = 691; } -x64Token x64Parser::tokenBranches7940[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, +x64Token x64Parser::tokenBranches7946[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7927[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, +x64Token x64Parser::tokenBranches7933[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7926[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927 }, +x64Token x64Parser::tokenBranches7932[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7925[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926 }, +x64Token x64Parser::tokenBranches7931[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7932 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) { - operand.operandCoding = 689; + operand.operandCoding = 690; } -x64Token x64Parser::tokenBranches7934[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, +x64Token x64Parser::tokenBranches7940[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7953(x64Operand &operand, int tokenPos) { - operand.operandCoding = 691; + operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7946[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, +x64Token x64Parser::tokenBranches7952[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7953, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) { - operand.operandCoding = 693; + operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7956[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, +x64Token x64Parser::tokenBranches7962[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7933[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, +x64Token x64Parser::tokenBranches7939[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7952 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7932[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, +x64Token x64Parser::tokenBranches7938[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7939 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7951(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) { - operand.operandCoding = 692; + operand.operandCoding = 693; } -x64Token x64Parser::tokenBranches7950[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7951, }, +x64Token x64Parser::tokenBranches7956[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7938(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32633,70 +32702,70 @@ void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7931[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7932, x64Parser::tokenBranches7932 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950 }, +x64Token x64Parser::tokenBranches7937[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7938, x64Parser::tokenBranches7938 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7924[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, +x64Token x64Parser::tokenBranches7930[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7937 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) { - operand.operandCoding = 694; + operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7962[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, +x64Token x64Parser::tokenBranches7968[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7961[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, +x64Token x64Parser::tokenBranches7967[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7960[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961 }, +x64Token x64Parser::tokenBranches7966[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7959[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960 }, +x64Token x64Parser::tokenBranches7965[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7966 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7975(x64Operand &operand, int tokenPos) { - operand.operandCoding = 695; + operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7968[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, +x64Token x64Parser::tokenBranches7974[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7975, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7985(x64Operand &operand, int tokenPos) { - operand.operandCoding = 695; + operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7978[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, +x64Token x64Parser::tokenBranches7984[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7985, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7967[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, +x64Token x64Parser::tokenBranches7973[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7974 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7984 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7966[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, +x64Token x64Parser::tokenBranches7972[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7973 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7973(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) { - operand.operandCoding = 694; + operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7972[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7973, }, +x64Token x64Parser::tokenBranches7978[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7972(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32708,132 +32777,132 @@ void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7965[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7966, x64Parser::tokenBranches7966 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972 }, +x64Token x64Parser::tokenBranches7971[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7972, x64Parser::tokenBranches7972 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7958[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, +x64Token x64Parser::tokenBranches7964[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7971 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7855[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958 }, +x64Token x64Parser::tokenBranches7861[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7862 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7896 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7930 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7964 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7984(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7990(x64Operand &operand, int tokenPos) { - operand.operandCoding = 696; + operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches7983[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7984, }, +x64Token x64Parser::tokenBranches7989[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7990, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_16[] = { +Coding x64Parser::tokenCoding8030_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_17[] = { +Coding x64Parser::tokenCoding8030_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_18[] = { +Coding x64Parser::tokenCoding8030_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_19[] = { +Coding x64Parser::tokenCoding8030_19[] = { { CODING_NAME("reg") Coding::stateFunc, 4 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8024(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8030(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8024_16; - operand.values[17] = tokenCoding8024_17; - operand.values[18] = tokenCoding8024_18; - operand.values[19] = tokenCoding8024_19; + operand.values[16] = tokenCoding8030_16; + operand.values[17] = tokenCoding8030_17; + operand.values[18] = tokenCoding8030_18; + operand.values[19] = tokenCoding8030_19; } -x64Token x64Parser::tokenBranches8023[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8024, }, +x64Token x64Parser::tokenBranches8029[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8030, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8034(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) { - operand.operandCoding = 697; + operand.operandCoding = 698; } -x64Token x64Parser::tokenBranches8033[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8034, }, +x64Token x64Parser::tokenBranches8039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) { - operand.operandCoding = 699; + operand.operandCoding = 700; } -x64Token x64Parser::tokenBranches8045[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, +x64Token x64Parser::tokenBranches8051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8032[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, +x64Token x64Parser::tokenBranches8038[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8031[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032 }, +x64Token x64Parser::tokenBranches8037[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8030[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031 }, +x64Token x64Parser::tokenBranches8036[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8037 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) { - operand.operandCoding = 698; + operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches8039[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, +x64Token x64Parser::tokenBranches8045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8058(x64Operand &operand, int tokenPos) { - operand.operandCoding = 700; + operand.operandCoding = 701; } -x64Token x64Parser::tokenBranches8051[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, +x64Token x64Parser::tokenBranches8057[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8058, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) { - operand.operandCoding = 702; + operand.operandCoding = 703; } -x64Token x64Parser::tokenBranches8061[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, +x64Token x64Parser::tokenBranches8067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8038[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, +x64Token x64Parser::tokenBranches8044[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8057 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8037[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, +x64Token x64Parser::tokenBranches8043[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8044 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8056(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) { - operand.operandCoding = 701; + operand.operandCoding = 702; } -x64Token x64Parser::tokenBranches8055[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8056, }, +x64Token x64Parser::tokenBranches8061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8043(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32845,88 +32914,88 @@ void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8036[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8037, x64Parser::tokenBranches8037 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055 }, +x64Token x64Parser::tokenBranches8042[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8043, x64Parser::tokenBranches8043 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8029[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, +x64Token x64Parser::tokenBranches8035[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8042 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) { - operand.operandCoding = 703; + operand.operandCoding = 704; } -x64Token x64Parser::tokenBranches8067[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, +x64Token x64Parser::tokenBranches8073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) { - operand.operandCoding = 705; + operand.operandCoding = 706; } -x64Token x64Parser::tokenBranches8079[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, +x64Token x64Parser::tokenBranches8085[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8066[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, +x64Token x64Parser::tokenBranches8072[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8065[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066 }, +x64Token x64Parser::tokenBranches8071[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8064[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065 }, +x64Token x64Parser::tokenBranches8070[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8071 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) { - operand.operandCoding = 704; + operand.operandCoding = 705; } -x64Token x64Parser::tokenBranches8073[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, +x64Token x64Parser::tokenBranches8079[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8092(x64Operand &operand, int tokenPos) { - operand.operandCoding = 706; + operand.operandCoding = 707; } -x64Token x64Parser::tokenBranches8085[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, +x64Token x64Parser::tokenBranches8091[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8092, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) { - operand.operandCoding = 708; + operand.operandCoding = 709; } -x64Token x64Parser::tokenBranches8095[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, +x64Token x64Parser::tokenBranches8101[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8072[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, +x64Token x64Parser::tokenBranches8078[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8091 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8071[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, +x64Token x64Parser::tokenBranches8077[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8078 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8090(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) { - operand.operandCoding = 707; + operand.operandCoding = 708; } -x64Token x64Parser::tokenBranches8089[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8090, }, +x64Token x64Parser::tokenBranches8095[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8077(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32938,88 +33007,88 @@ void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8070[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8071, x64Parser::tokenBranches8071 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089 }, +x64Token x64Parser::tokenBranches8076[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8077, x64Parser::tokenBranches8077 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8063[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, +x64Token x64Parser::tokenBranches8069[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8076 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) { - operand.operandCoding = 709; + operand.operandCoding = 710; } -x64Token x64Parser::tokenBranches8101[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, +x64Token x64Parser::tokenBranches8107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) { - operand.operandCoding = 711; + operand.operandCoding = 712; } -x64Token x64Parser::tokenBranches8113[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, +x64Token x64Parser::tokenBranches8119[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8100[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, +x64Token x64Parser::tokenBranches8106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8099[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100 }, +x64Token x64Parser::tokenBranches8105[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8098[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099 }, +x64Token x64Parser::tokenBranches8104[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8105 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) { - operand.operandCoding = 710; + operand.operandCoding = 711; } -x64Token x64Parser::tokenBranches8107[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, +x64Token x64Parser::tokenBranches8113[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8126(x64Operand &operand, int tokenPos) { - operand.operandCoding = 712; + operand.operandCoding = 713; } -x64Token x64Parser::tokenBranches8119[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, +x64Token x64Parser::tokenBranches8125[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8126, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) { - operand.operandCoding = 714; + operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8129[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, +x64Token x64Parser::tokenBranches8135[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8106[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, +x64Token x64Parser::tokenBranches8112[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8125 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8105[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, +x64Token x64Parser::tokenBranches8111[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8112 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8124(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) { - operand.operandCoding = 713; + operand.operandCoding = 714; } -x64Token x64Parser::tokenBranches8123[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8124, }, +x64Token x64Parser::tokenBranches8129[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8111(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -33031,70 +33100,70 @@ void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8104[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8105, x64Parser::tokenBranches8105 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123 }, +x64Token x64Parser::tokenBranches8110[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8111, x64Parser::tokenBranches8111 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8097[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, +x64Token x64Parser::tokenBranches8103[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8110 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) { - operand.operandCoding = 715; + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8135[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, +x64Token x64Parser::tokenBranches8141[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8134[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, +x64Token x64Parser::tokenBranches8140[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8133[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134 }, +x64Token x64Parser::tokenBranches8139[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8132[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133 }, +x64Token x64Parser::tokenBranches8138[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8139 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8148(x64Operand &operand, int tokenPos) { - operand.operandCoding = 716; + operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8141[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, +x64Token x64Parser::tokenBranches8147[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8148, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8158(x64Operand &operand, int tokenPos) { - operand.operandCoding = 716; + operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8151[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, +x64Token x64Parser::tokenBranches8157[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8158, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8140[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, +x64Token x64Parser::tokenBranches8146[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8147 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8157 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8139[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, +x64Token x64Parser::tokenBranches8145[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8146 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8146(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) { - operand.operandCoding = 715; + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8145[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8146, }, +x64Token x64Parser::tokenBranches8151[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8145(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -33106,115 +33175,115 @@ void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8138[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8139, x64Parser::tokenBranches8139 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145 }, +x64Token x64Parser::tokenBranches8144[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8145, x64Parser::tokenBranches8145 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8131[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, +x64Token x64Parser::tokenBranches8137[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8144 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8028[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131 }, +x64Token x64Parser::tokenBranches8034[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8035 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8069 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8103 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8137 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8157(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8163(x64Operand &operand, int tokenPos) { - operand.operandCoding = 717; + operand.operandCoding = 718; } -x64Token x64Parser::tokenBranches8156[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8157, }, +x64Token x64Parser::tokenBranches8162[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8163, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8159_16[] = { +Coding x64Parser::tokenCoding8165_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_17[] = { +Coding x64Parser::tokenCoding8165_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_18[] = { +Coding x64Parser::tokenCoding8165_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_19[] = { +Coding x64Parser::tokenCoding8165_19[] = { { CODING_NAME("reg") Coding::stateFunc, 4 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8159(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8165(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8159_16; - operand.values[17] = tokenCoding8159_17; - operand.values[18] = tokenCoding8159_18; - operand.values[19] = tokenCoding8159_19; + operand.values[16] = tokenCoding8165_16; + operand.values[17] = tokenCoding8165_17; + operand.values[18] = tokenCoding8165_18; + operand.values[19] = tokenCoding8165_19; } -Coding x64Parser::tokenCoding8160_16[] = { +Coding x64Parser::tokenCoding8166_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_17[] = { +Coding x64Parser::tokenCoding8166_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_18[] = { +Coding x64Parser::tokenCoding8166_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_19[] = { +Coding x64Parser::tokenCoding8166_19[] = { { CODING_NAME("reg") Coding::stateFunc, 5 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8160(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8166(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8160_16; - operand.values[17] = tokenCoding8160_17; - operand.values[18] = tokenCoding8160_18; - operand.values[19] = tokenCoding8160_19; + operand.values[16] = tokenCoding8166_16; + operand.values[17] = tokenCoding8166_17; + operand.values[18] = tokenCoding8166_18; + operand.values[19] = tokenCoding8166_19; } -Coding x64Parser::tokenCoding8161_16[] = { +Coding x64Parser::tokenCoding8167_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_17[] = { +Coding x64Parser::tokenCoding8167_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_18[] = { +Coding x64Parser::tokenCoding8167_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_19[] = { +Coding x64Parser::tokenCoding8167_19[] = { { CODING_NAME("reg") Coding::stateFunc, 6 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8161(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8167(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8161_16; - operand.values[17] = tokenCoding8161_17; - operand.values[18] = tokenCoding8161_18; - operand.values[19] = tokenCoding8161_19; + operand.values[16] = tokenCoding8167_16; + operand.values[17] = tokenCoding8167_17; + operand.values[18] = tokenCoding8167_18; + operand.values[19] = tokenCoding8167_19; } -x64Token x64Parser::tokenBranches8158[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8159, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8160, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8161, }, +x64Token x64Parser::tokenBranches8164[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8165, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8166, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8167, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8177(x64Operand &operand, int tokenPos) { - operand.operandCoding = 718; + operand.operandCoding = 719; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33226,21 +33295,21 @@ void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8170[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8171, }, +x64Token x64Parser::tokenBranches8176[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8177, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8169[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170 }, +x64Token x64Parser::tokenBranches8175[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8176 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8168[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169 }, +x64Token x64Parser::tokenBranches8174[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8175 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8181(x64Operand &operand, int tokenPos) { - operand.operandCoding = 719; + operand.operandCoding = 720; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33252,21 +33321,21 @@ void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8174[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8175, }, +x64Token x64Parser::tokenBranches8180[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8181, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8173[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174 }, +x64Token x64Parser::tokenBranches8179[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8180 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8172[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173 }, +x64Token x64Parser::tokenBranches8178[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8179 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8185(x64Operand &operand, int tokenPos) { - operand.operandCoding = 720; + operand.operandCoding = 721; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33278,21 +33347,21 @@ void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8178[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8179, }, +x64Token x64Parser::tokenBranches8184[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8185, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8177[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178 }, +x64Token x64Parser::tokenBranches8183[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8176[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177 }, +x64Token x64Parser::tokenBranches8182[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8183 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8189(x64Operand &operand, int tokenPos) { - operand.operandCoding = 721; + operand.operandCoding = 722; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33304,35 +33373,35 @@ void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8182[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8183, }, +x64Token x64Parser::tokenBranches8188[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8189, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8181[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182 }, +x64Token x64Parser::tokenBranches8187[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8188 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8180[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181 }, +x64Token x64Parser::tokenBranches8186[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8187 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8187_16[] = { +Coding x64Parser::tokenCoding8193_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_17[] = { +Coding x64Parser::tokenCoding8193_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_18[] = { +Coding x64Parser::tokenCoding8193_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_19[] = { +Coding x64Parser::tokenCoding8193_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8193(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33343,32 +33412,32 @@ void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8187_16; - operand.values[17] = tokenCoding8187_17; - operand.values[18] = tokenCoding8187_18; - operand.values[19] = tokenCoding8187_19; + operand.values[16] = tokenCoding8193_16; + operand.values[17] = tokenCoding8193_17; + operand.values[18] = tokenCoding8193_18; + operand.values[19] = tokenCoding8193_19; } -Coding x64Parser::tokenCoding8191_16[] = { +Coding x64Parser::tokenCoding8197_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_17[] = { +Coding x64Parser::tokenCoding8197_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_23[] = { +Coding x64Parser::tokenCoding8197_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_18[] = { +Coding x64Parser::tokenCoding8197_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_19[] = { +Coding x64Parser::tokenCoding8197_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8197(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33379,43 +33448,43 @@ void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8191_16; - operand.values[17] = tokenCoding8191_17; - operand.values[23] = tokenCoding8191_23; - operand.values[18] = tokenCoding8191_18; - operand.values[19] = tokenCoding8191_19; + operand.values[16] = tokenCoding8197_16; + operand.values[17] = tokenCoding8197_17; + operand.values[23] = tokenCoding8197_23; + operand.values[18] = tokenCoding8197_18; + operand.values[19] = tokenCoding8197_19; } -x64Token x64Parser::tokenBranches8186[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8187, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8191, }, +x64Token x64Parser::tokenBranches8192[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8193, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8197, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8185[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, +x64Token x64Parser::tokenBranches8191[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8192 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8184[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185 }, +x64Token x64Parser::tokenBranches8190[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8191 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8195_16[] = { +Coding x64Parser::tokenCoding8201_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_17[] = { +Coding x64Parser::tokenCoding8201_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_18[] = { +Coding x64Parser::tokenCoding8201_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_19[] = { +Coding x64Parser::tokenCoding8201_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8201(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33426,41 +33495,41 @@ void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8195_16; - operand.values[17] = tokenCoding8195_17; - operand.values[18] = tokenCoding8195_18; - operand.values[19] = tokenCoding8195_19; + operand.values[16] = tokenCoding8201_16; + operand.values[17] = tokenCoding8201_17; + operand.values[18] = tokenCoding8201_18; + operand.values[19] = tokenCoding8201_19; } -x64Token x64Parser::tokenBranches8194[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8195, }, +x64Token x64Parser::tokenBranches8200[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8201, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8193[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194 }, +x64Token x64Parser::tokenBranches8199[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8200 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8192[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193 }, +x64Token x64Parser::tokenBranches8198[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8199 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8199_16[] = { +Coding x64Parser::tokenCoding8205_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_17[] = { +Coding x64Parser::tokenCoding8205_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_18[] = { +Coding x64Parser::tokenCoding8205_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_19[] = { +Coding x64Parser::tokenCoding8205_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8205(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33471,41 +33540,41 @@ void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8199_16; - operand.values[17] = tokenCoding8199_17; - operand.values[18] = tokenCoding8199_18; - operand.values[19] = tokenCoding8199_19; + operand.values[16] = tokenCoding8205_16; + operand.values[17] = tokenCoding8205_17; + operand.values[18] = tokenCoding8205_18; + operand.values[19] = tokenCoding8205_19; } -x64Token x64Parser::tokenBranches8198[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8199, }, +x64Token x64Parser::tokenBranches8204[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8205, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8197[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198 }, +x64Token x64Parser::tokenBranches8203[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8196[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197 }, +x64Token x64Parser::tokenBranches8202[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8203 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8203_16[] = { +Coding x64Parser::tokenCoding8209_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_17[] = { +Coding x64Parser::tokenCoding8209_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_18[] = { +Coding x64Parser::tokenCoding8209_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_19[] = { +Coding x64Parser::tokenCoding8209_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33516,40 +33585,40 @@ void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8203_16; - operand.values[17] = tokenCoding8203_17; - operand.values[18] = tokenCoding8203_18; - operand.values[19] = tokenCoding8203_19; + operand.values[16] = tokenCoding8209_16; + operand.values[17] = tokenCoding8209_17; + operand.values[18] = tokenCoding8209_18; + operand.values[19] = tokenCoding8209_19; } -x64Token x64Parser::tokenBranches8202[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8203, }, +x64Token x64Parser::tokenBranches8208[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8209, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8201[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202 }, +x64Token x64Parser::tokenBranches8207[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8200[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201 }, +x64Token x64Parser::tokenBranches8206[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8248_16[] = { +Coding x64Parser::tokenCoding8254_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_17[] = { +Coding x64Parser::tokenCoding8254_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_18[] = { +Coding x64Parser::tokenCoding8254_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_19[] = { +Coding x64Parser::tokenCoding8254_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8254(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -33562,32 +33631,32 @@ void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8248_16; - operand.values[17] = tokenCoding8248_17; - operand.values[18] = tokenCoding8248_18; - operand.values[19] = tokenCoding8248_19; + operand.values[16] = tokenCoding8254_16; + operand.values[17] = tokenCoding8254_17; + operand.values[18] = tokenCoding8254_18; + operand.values[19] = tokenCoding8254_19; } -x64Token x64Parser::tokenBranches8247[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8248, }, +x64Token x64Parser::tokenBranches8253[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8254, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8206_16[] = { +Coding x64Parser::tokenCoding8212_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_17[] = { +Coding x64Parser::tokenCoding8212_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_18[] = { +Coding x64Parser::tokenCoding8212_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_19[] = { +Coding x64Parser::tokenCoding8212_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33598,32 +33667,32 @@ void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8206_16; - operand.values[17] = tokenCoding8206_17; - operand.values[18] = tokenCoding8206_18; - operand.values[19] = tokenCoding8206_19; + operand.values[16] = tokenCoding8212_16; + operand.values[17] = tokenCoding8212_17; + operand.values[18] = tokenCoding8212_18; + operand.values[19] = tokenCoding8212_19; } -Coding x64Parser::tokenCoding8212_16[] = { +Coding x64Parser::tokenCoding8218_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_17[] = { +Coding x64Parser::tokenCoding8218_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_23[] = { +Coding x64Parser::tokenCoding8218_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_18[] = { +Coding x64Parser::tokenCoding8218_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_19[] = { +Coding x64Parser::tokenCoding8218_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33634,43 +33703,43 @@ void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8212_16; - operand.values[17] = tokenCoding8212_17; - operand.values[23] = tokenCoding8212_23; - operand.values[18] = tokenCoding8212_18; - operand.values[19] = tokenCoding8212_19; + operand.values[16] = tokenCoding8218_16; + operand.values[17] = tokenCoding8218_17; + operand.values[23] = tokenCoding8218_23; + operand.values[18] = tokenCoding8218_18; + operand.values[19] = tokenCoding8218_19; } -x64Token x64Parser::tokenBranches8205[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8206, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8212, }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247 }, +x64Token x64Parser::tokenBranches8211[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8212, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8218, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8253 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8204[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205 }, +x64Token x64Parser::tokenBranches8210[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8211 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8209_16[] = { +Coding x64Parser::tokenCoding8215_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_17[] = { +Coding x64Parser::tokenCoding8215_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_23[] = { +Coding x64Parser::tokenCoding8215_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_18[] = { +Coding x64Parser::tokenCoding8215_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_19[] = { +Coding x64Parser::tokenCoding8215_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33681,33 +33750,33 @@ void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8209_16; - operand.values[17] = tokenCoding8209_17; - operand.values[23] = tokenCoding8209_23; - operand.values[18] = tokenCoding8209_18; - operand.values[19] = tokenCoding8209_19; + operand.values[16] = tokenCoding8215_16; + operand.values[17] = tokenCoding8215_17; + operand.values[23] = tokenCoding8215_23; + operand.values[18] = tokenCoding8215_18; + operand.values[19] = tokenCoding8215_19; } -Coding x64Parser::tokenCoding8215_16[] = { +Coding x64Parser::tokenCoding8221_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_17[] = { +Coding x64Parser::tokenCoding8221_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_23[] = { +Coding x64Parser::tokenCoding8221_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_18[] = { +Coding x64Parser::tokenCoding8221_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_19[] = { +Coding x64Parser::tokenCoding8221_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33718,41 +33787,41 @@ void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8215_16; - operand.values[17] = tokenCoding8215_17; - operand.values[23] = tokenCoding8215_23; - operand.values[18] = tokenCoding8215_18; - operand.values[19] = tokenCoding8215_19; + operand.values[16] = tokenCoding8221_16; + operand.values[17] = tokenCoding8221_17; + operand.values[23] = tokenCoding8221_23; + operand.values[18] = tokenCoding8221_18; + operand.values[19] = tokenCoding8221_19; } -x64Token x64Parser::tokenBranches8208[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8209, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8215, }, +x64Token x64Parser::tokenBranches8214[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8215, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8221, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8207[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, +x64Token x64Parser::tokenBranches8213[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8214 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8252_16[] = { +Coding x64Parser::tokenCoding8258_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_17[] = { +Coding x64Parser::tokenCoding8258_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_18[] = { +Coding x64Parser::tokenCoding8258_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_19[] = { +Coding x64Parser::tokenCoding8258_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8258(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33763,33 +33832,33 @@ void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8252_16; - operand.values[17] = tokenCoding8252_17; - operand.values[18] = tokenCoding8252_18; - operand.values[19] = tokenCoding8252_19; + operand.values[16] = tokenCoding8258_16; + operand.values[17] = tokenCoding8258_17; + operand.values[18] = tokenCoding8258_18; + operand.values[19] = tokenCoding8258_19; } -x64Token x64Parser::tokenBranches8251[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8252, }, +x64Token x64Parser::tokenBranches8257[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8258, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8218_16[] = { +Coding x64Parser::tokenCoding8224_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_17[] = { +Coding x64Parser::tokenCoding8224_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_18[] = { +Coding x64Parser::tokenCoding8224_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_19[] = { +Coding x64Parser::tokenCoding8224_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33800,40 +33869,40 @@ void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8218_16; - operand.values[17] = tokenCoding8218_17; - operand.values[18] = tokenCoding8218_18; - operand.values[19] = tokenCoding8218_19; + operand.values[16] = tokenCoding8224_16; + operand.values[17] = tokenCoding8224_17; + operand.values[18] = tokenCoding8224_18; + operand.values[19] = tokenCoding8224_19; } -x64Token x64Parser::tokenBranches8217[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8218, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251 }, +x64Token x64Parser::tokenBranches8223[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8224, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8257 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8216[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217 }, +x64Token x64Parser::tokenBranches8222[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8256_16[] = { +Coding x64Parser::tokenCoding8262_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_17[] = { +Coding x64Parser::tokenCoding8262_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_18[] = { +Coding x64Parser::tokenCoding8262_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_19[] = { +Coding x64Parser::tokenCoding8262_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8262(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33844,33 +33913,33 @@ void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8256_16; - operand.values[17] = tokenCoding8256_17; - operand.values[18] = tokenCoding8256_18; - operand.values[19] = tokenCoding8256_19; + operand.values[16] = tokenCoding8262_16; + operand.values[17] = tokenCoding8262_17; + operand.values[18] = tokenCoding8262_18; + operand.values[19] = tokenCoding8262_19; } -x64Token x64Parser::tokenBranches8255[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8256, }, +x64Token x64Parser::tokenBranches8261[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8262, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8221_16[] = { +Coding x64Parser::tokenCoding8227_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_17[] = { +Coding x64Parser::tokenCoding8227_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_18[] = { +Coding x64Parser::tokenCoding8227_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_19[] = { +Coding x64Parser::tokenCoding8227_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8227(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33881,40 +33950,40 @@ void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8221_16; - operand.values[17] = tokenCoding8221_17; - operand.values[18] = tokenCoding8221_18; - operand.values[19] = tokenCoding8221_19; + operand.values[16] = tokenCoding8227_16; + operand.values[17] = tokenCoding8227_17; + operand.values[18] = tokenCoding8227_18; + operand.values[19] = tokenCoding8227_19; } -x64Token x64Parser::tokenBranches8220[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8221, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255 }, +x64Token x64Parser::tokenBranches8226[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8227, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8261 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8219[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220 }, +x64Token x64Parser::tokenBranches8225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8260_16[] = { +Coding x64Parser::tokenCoding8266_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_17[] = { +Coding x64Parser::tokenCoding8266_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_18[] = { +Coding x64Parser::tokenCoding8266_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_19[] = { +Coding x64Parser::tokenCoding8266_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8266(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33925,33 +33994,33 @@ void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8260_16; - operand.values[17] = tokenCoding8260_17; - operand.values[18] = tokenCoding8260_18; - operand.values[19] = tokenCoding8260_19; + operand.values[16] = tokenCoding8266_16; + operand.values[17] = tokenCoding8266_17; + operand.values[18] = tokenCoding8266_18; + operand.values[19] = tokenCoding8266_19; } -x64Token x64Parser::tokenBranches8259[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8260, }, +x64Token x64Parser::tokenBranches8265[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8266, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8224_16[] = { +Coding x64Parser::tokenCoding8230_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_17[] = { +Coding x64Parser::tokenCoding8230_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_18[] = { +Coding x64Parser::tokenCoding8230_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_19[] = { +Coding x64Parser::tokenCoding8230_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8230(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33962,220 +34031,220 @@ void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8224_16; - operand.values[17] = tokenCoding8224_17; - operand.values[18] = tokenCoding8224_18; - operand.values[19] = tokenCoding8224_19; + operand.values[16] = tokenCoding8230_16; + operand.values[17] = tokenCoding8230_17; + operand.values[18] = tokenCoding8230_18; + operand.values[19] = tokenCoding8230_19; } -x64Token x64Parser::tokenBranches8223[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8224, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259 }, +x64Token x64Parser::tokenBranches8229[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8230, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8265 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8222[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, +x64Token x64Parser::tokenBranches8228[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8229 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8228_16[] = { +Coding x64Parser::tokenCoding8234_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_17[] = { +Coding x64Parser::tokenCoding8234_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_18[] = { +Coding x64Parser::tokenCoding8234_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_19[] = { +Coding x64Parser::tokenCoding8234_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8228(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8234(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8228_16; - operand.values[17] = tokenCoding8228_17; - operand.values[18] = tokenCoding8228_18; - operand.values[19] = tokenCoding8228_19; + operand.values[16] = tokenCoding8234_16; + operand.values[17] = tokenCoding8234_17; + operand.values[18] = tokenCoding8234_18; + operand.values[19] = tokenCoding8234_19; } -x64Token x64Parser::tokenBranches8227[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8228, }, +x64Token x64Parser::tokenBranches8233[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8234, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8226[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227 }, +x64Token x64Parser::tokenBranches8232[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8233 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8225[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, +x64Token x64Parser::tokenBranches8231[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8232 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8232_16[] = { +Coding x64Parser::tokenCoding8238_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_17[] = { +Coding x64Parser::tokenCoding8238_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_23[] = { +Coding x64Parser::tokenCoding8238_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_18[] = { +Coding x64Parser::tokenCoding8238_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_19[] = { +Coding x64Parser::tokenCoding8238_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8232(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8238(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8232_16; - operand.values[17] = tokenCoding8232_17; - operand.values[23] = tokenCoding8232_23; - operand.values[18] = tokenCoding8232_18; - operand.values[19] = tokenCoding8232_19; + operand.values[16] = tokenCoding8238_16; + operand.values[17] = tokenCoding8238_17; + operand.values[23] = tokenCoding8238_23; + operand.values[18] = tokenCoding8238_18; + operand.values[19] = tokenCoding8238_19; } -x64Token x64Parser::tokenBranches8231[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8232, }, +x64Token x64Parser::tokenBranches8237[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8238, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8230[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231 }, +x64Token x64Parser::tokenBranches8236[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8237 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8229[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230 }, +x64Token x64Parser::tokenBranches8235[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8236 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8236_16[] = { +Coding x64Parser::tokenCoding8242_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_17[] = { +Coding x64Parser::tokenCoding8242_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_18[] = { +Coding x64Parser::tokenCoding8242_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_19[] = { +Coding x64Parser::tokenCoding8242_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8236(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8242(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8236_16; - operand.values[17] = tokenCoding8236_17; - operand.values[18] = tokenCoding8236_18; - operand.values[19] = tokenCoding8236_19; + operand.values[16] = tokenCoding8242_16; + operand.values[17] = tokenCoding8242_17; + operand.values[18] = tokenCoding8242_18; + operand.values[19] = tokenCoding8242_19; } -x64Token x64Parser::tokenBranches8235[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8236, }, +x64Token x64Parser::tokenBranches8241[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8242, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8234[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235 }, +x64Token x64Parser::tokenBranches8240[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8241 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8233[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234 }, +x64Token x64Parser::tokenBranches8239[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8240 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8240_16[] = { +Coding x64Parser::tokenCoding8246_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_17[] = { +Coding x64Parser::tokenCoding8246_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_18[] = { +Coding x64Parser::tokenCoding8246_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_19[] = { +Coding x64Parser::tokenCoding8246_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8240(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8246(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8240_16; - operand.values[17] = tokenCoding8240_17; - operand.values[18] = tokenCoding8240_18; - operand.values[19] = tokenCoding8240_19; + operand.values[16] = tokenCoding8246_16; + operand.values[17] = tokenCoding8246_17; + operand.values[18] = tokenCoding8246_18; + operand.values[19] = tokenCoding8246_19; } -x64Token x64Parser::tokenBranches8239[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8240, }, +x64Token x64Parser::tokenBranches8245[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8246, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8238[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239 }, +x64Token x64Parser::tokenBranches8244[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8245 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8237[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238 }, +x64Token x64Parser::tokenBranches8243[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8244 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8244_16[] = { +Coding x64Parser::tokenCoding8250_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_17[] = { +Coding x64Parser::tokenCoding8250_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_18[] = { +Coding x64Parser::tokenCoding8250_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_19[] = { +Coding x64Parser::tokenCoding8250_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8244(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8250(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8244_16; - operand.values[17] = tokenCoding8244_17; - operand.values[18] = tokenCoding8244_18; - operand.values[19] = tokenCoding8244_19; + operand.values[16] = tokenCoding8250_16; + operand.values[17] = tokenCoding8250_17; + operand.values[18] = tokenCoding8250_18; + operand.values[19] = tokenCoding8250_19; } -x64Token x64Parser::tokenBranches8243[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8244, }, +x64Token x64Parser::tokenBranches8249[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8250, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8242[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243 }, +x64Token x64Parser::tokenBranches8248[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8249 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8241[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242 }, +x64Token x64Parser::tokenBranches8247[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8248 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8265_16[] = { +Coding x64Parser::tokenCoding8271_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_17[] = { +Coding x64Parser::tokenCoding8271_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_18[] = { +Coding x64Parser::tokenCoding8271_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_19[] = { +Coding x64Parser::tokenCoding8271_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8271(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -34188,47 +34257,47 @@ void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8265_16; - operand.values[17] = tokenCoding8265_17; - operand.values[18] = tokenCoding8265_18; - operand.values[19] = tokenCoding8265_19; + operand.values[16] = tokenCoding8271_16; + operand.values[17] = tokenCoding8271_17; + operand.values[18] = tokenCoding8271_18; + operand.values[19] = tokenCoding8271_19; } -x64Token x64Parser::tokenBranches8264[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8265, }, +x64Token x64Parser::tokenBranches8270[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8271, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8263[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264 }, +x64Token x64Parser::tokenBranches8269[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8270 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8262[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263 }, +x64Token x64Parser::tokenBranches8268[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8269 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8261[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262 }, +x64Token x64Parser::tokenBranches8267[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8270_16[] = { +Coding x64Parser::tokenCoding8276_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_17[] = { +Coding x64Parser::tokenCoding8276_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_18[] = { +Coding x64Parser::tokenCoding8276_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_19[] = { +Coding x64Parser::tokenCoding8276_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8276(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34239,47 +34308,47 @@ void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8270_16; - operand.values[17] = tokenCoding8270_17; - operand.values[18] = tokenCoding8270_18; - operand.values[19] = tokenCoding8270_19; + operand.values[16] = tokenCoding8276_16; + operand.values[17] = tokenCoding8276_17; + operand.values[18] = tokenCoding8276_18; + operand.values[19] = tokenCoding8276_19; } -x64Token x64Parser::tokenBranches8269[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8270, }, +x64Token x64Parser::tokenBranches8275[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8276, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8268[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269 }, +x64Token x64Parser::tokenBranches8274[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8275 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8267[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, +x64Token x64Parser::tokenBranches8273[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8274 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8266[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, +x64Token x64Parser::tokenBranches8272[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8275_16[] = { +Coding x64Parser::tokenCoding8281_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_17[] = { +Coding x64Parser::tokenCoding8281_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_18[] = { +Coding x64Parser::tokenCoding8281_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_19[] = { +Coding x64Parser::tokenCoding8281_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8281(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34290,47 +34359,47 @@ void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8275_16; - operand.values[17] = tokenCoding8275_17; - operand.values[18] = tokenCoding8275_18; - operand.values[19] = tokenCoding8275_19; + operand.values[16] = tokenCoding8281_16; + operand.values[17] = tokenCoding8281_17; + operand.values[18] = tokenCoding8281_18; + operand.values[19] = tokenCoding8281_19; } -x64Token x64Parser::tokenBranches8274[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8275, }, +x64Token x64Parser::tokenBranches8280[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8281, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8273[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274 }, +x64Token x64Parser::tokenBranches8279[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8272[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, +x64Token x64Parser::tokenBranches8278[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8279 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8271[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, +x64Token x64Parser::tokenBranches8277[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8280_16[] = { +Coding x64Parser::tokenCoding8286_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_17[] = { +Coding x64Parser::tokenCoding8286_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_18[] = { +Coding x64Parser::tokenCoding8286_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_19[] = { +Coding x64Parser::tokenCoding8286_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8286(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34341,28 +34410,28 @@ void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8280_16; - operand.values[17] = tokenCoding8280_17; - operand.values[18] = tokenCoding8280_18; - operand.values[19] = tokenCoding8280_19; + operand.values[16] = tokenCoding8286_16; + operand.values[17] = tokenCoding8286_17; + operand.values[18] = tokenCoding8286_18; + operand.values[19] = tokenCoding8286_19; } -x64Token x64Parser::tokenBranches8279[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8280, }, +x64Token x64Parser::tokenBranches8285[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8286, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8278[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279 }, +x64Token x64Parser::tokenBranches8284[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8285 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8277[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, +x64Token x64Parser::tokenBranches8283[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8276[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, +x64Token x64Parser::tokenBranches8282[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8283 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8231(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34374,7 +34443,7 @@ void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8235(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34386,7 +34455,7 @@ void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8239(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34398,7 +34467,7 @@ void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8243(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34410,7 +34479,7 @@ void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8247(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34422,105 +34491,105 @@ void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8167[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200 }, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, - {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216 }, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8225, x64Parser::tokenBranches8225 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8229, x64Parser::tokenBranches8229 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8233, x64Parser::tokenBranches8233 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8237, x64Parser::tokenBranches8237 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8241, x64Parser::tokenBranches8241 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8283_16[] = { +x64Token x64Parser::tokenBranches8173[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8174 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8178 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8182 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8190 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8198 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8202 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8206 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8210 }, + {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8213 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8225 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8228 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8231, x64Parser::tokenBranches8231 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8235, x64Parser::tokenBranches8235 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8239, x64Parser::tokenBranches8239 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8243, x64Parser::tokenBranches8243 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8247, x64Parser::tokenBranches8247 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8282 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8289_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_17[] = { +Coding x64Parser::tokenCoding8289_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_18[] = { +Coding x64Parser::tokenCoding8289_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_19[] = { +Coding x64Parser::tokenCoding8289_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8289(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8283_16; - operand.values[17] = tokenCoding8283_17; - operand.values[18] = tokenCoding8283_18; - operand.values[19] = tokenCoding8283_19; + operand.values[16] = tokenCoding8289_16; + operand.values[17] = tokenCoding8289_17; + operand.values[18] = tokenCoding8289_18; + operand.values[19] = tokenCoding8289_19; } -x64Token x64Parser::tokenBranches8282[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8283, }, +x64Token x64Parser::tokenBranches8288[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8289, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8285_16[] = { +Coding x64Parser::tokenCoding8291_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_17[] = { +Coding x64Parser::tokenCoding8291_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_18[] = { +Coding x64Parser::tokenCoding8291_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_19[] = { +Coding x64Parser::tokenCoding8291_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8285(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8291(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8285_16; - operand.values[17] = tokenCoding8285_17; - operand.values[18] = tokenCoding8285_18; - operand.values[19] = tokenCoding8285_19; + operand.values[16] = tokenCoding8291_16; + operand.values[17] = tokenCoding8291_17; + operand.values[18] = tokenCoding8291_18; + operand.values[19] = tokenCoding8291_19; } -x64Token x64Parser::tokenBranches8284[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8285, }, +x64Token x64Parser::tokenBranches8290[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8291, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8293_16[] = { +Coding x64Parser::tokenCoding8299_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_17[] = { +Coding x64Parser::tokenCoding8299_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_18[] = { +Coding x64Parser::tokenCoding8299_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_19[] = { +Coding x64Parser::tokenCoding8299_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8299(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34531,33 +34600,33 @@ void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8293_16; - operand.values[17] = tokenCoding8293_17; - operand.values[18] = tokenCoding8293_18; - operand.values[19] = tokenCoding8293_19; + operand.values[16] = tokenCoding8299_16; + operand.values[17] = tokenCoding8299_17; + operand.values[18] = tokenCoding8299_18; + operand.values[19] = tokenCoding8299_19; } -Coding x64Parser::tokenCoding8297_16[] = { +Coding x64Parser::tokenCoding8303_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_17[] = { +Coding x64Parser::tokenCoding8303_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_23[] = { +Coding x64Parser::tokenCoding8303_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_18[] = { +Coding x64Parser::tokenCoding8303_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_19[] = { +Coding x64Parser::tokenCoding8303_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8303(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34568,44 +34637,44 @@ void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8297_16; - operand.values[17] = tokenCoding8297_17; - operand.values[23] = tokenCoding8297_23; - operand.values[18] = tokenCoding8297_18; - operand.values[19] = tokenCoding8297_19; + operand.values[16] = tokenCoding8303_16; + operand.values[17] = tokenCoding8303_17; + operand.values[23] = tokenCoding8303_23; + operand.values[18] = tokenCoding8303_18; + operand.values[19] = tokenCoding8303_19; } -x64Token x64Parser::tokenBranches8292[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8293, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8297, }, +x64Token x64Parser::tokenBranches8298[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8299, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8303, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8291[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292 }, +x64Token x64Parser::tokenBranches8297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8298 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8290[] = { - {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291 }, +x64Token x64Parser::tokenBranches8296[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8297 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8301_16[] = { +Coding x64Parser::tokenCoding8307_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_17[] = { +Coding x64Parser::tokenCoding8307_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_18[] = { +Coding x64Parser::tokenCoding8307_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_19[] = { +Coding x64Parser::tokenCoding8307_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8307(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34616,42 +34685,42 @@ void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8301_16; - operand.values[17] = tokenCoding8301_17; - operand.values[18] = tokenCoding8301_18; - operand.values[19] = tokenCoding8301_19; + operand.values[16] = tokenCoding8307_16; + operand.values[17] = tokenCoding8307_17; + operand.values[18] = tokenCoding8307_18; + operand.values[19] = tokenCoding8307_19; } -x64Token x64Parser::tokenBranches8300[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8301, }, +x64Token x64Parser::tokenBranches8306[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8307, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8299[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300 }, +x64Token x64Parser::tokenBranches8305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8306 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8298[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299 }, +x64Token x64Parser::tokenBranches8304[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8305 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8305_16[] = { +Coding x64Parser::tokenCoding8311_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_17[] = { +Coding x64Parser::tokenCoding8311_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_18[] = { +Coding x64Parser::tokenCoding8311_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_19[] = { +Coding x64Parser::tokenCoding8311_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8311(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34662,42 +34731,42 @@ void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8305_16; - operand.values[17] = tokenCoding8305_17; - operand.values[18] = tokenCoding8305_18; - operand.values[19] = tokenCoding8305_19; + operand.values[16] = tokenCoding8311_16; + operand.values[17] = tokenCoding8311_17; + operand.values[18] = tokenCoding8311_18; + operand.values[19] = tokenCoding8311_19; } -x64Token x64Parser::tokenBranches8304[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8305, }, +x64Token x64Parser::tokenBranches8310[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8311, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8303[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304 }, +x64Token x64Parser::tokenBranches8309[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8310 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8302[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303 }, +x64Token x64Parser::tokenBranches8308[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8309 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8309_16[] = { +Coding x64Parser::tokenCoding8315_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_17[] = { +Coding x64Parser::tokenCoding8315_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_18[] = { +Coding x64Parser::tokenCoding8315_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_19[] = { +Coding x64Parser::tokenCoding8315_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8315(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34708,33 +34777,33 @@ void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8309_16; - operand.values[17] = tokenCoding8309_17; - operand.values[18] = tokenCoding8309_18; - operand.values[19] = tokenCoding8309_19; + operand.values[16] = tokenCoding8315_16; + operand.values[17] = tokenCoding8315_17; + operand.values[18] = tokenCoding8315_18; + operand.values[19] = tokenCoding8315_19; } -x64Token x64Parser::tokenBranches8308[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8309, }, +x64Token x64Parser::tokenBranches8314[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8315, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8307[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308 }, +x64Token x64Parser::tokenBranches8313[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8306[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307 }, +x64Token x64Parser::tokenBranches8312[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8313 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8289[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306 }, +x64Token x64Parser::tokenBranches8295[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8296 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8304 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8308 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8312 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) { - operand.operandCoding = 722; + operand.operandCoding = 723; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34745,17 +34814,17 @@ void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8312[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8313, }, +x64Token x64Parser::tokenBranches8318[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8319, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8311[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312 }, +x64Token x64Parser::tokenBranches8317[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) { - operand.operandCoding = 723; + operand.operandCoding = 724; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34766,17 +34835,17 @@ void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8315[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8316, }, +x64Token x64Parser::tokenBranches8321[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8322, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8314[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315 }, +x64Token x64Parser::tokenBranches8320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) { - operand.operandCoding = 724; + operand.operandCoding = 725; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34787,229 +34856,229 @@ void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8318[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8319, }, +x64Token x64Parser::tokenBranches8324[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8325, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8317[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, +x64Token x64Parser::tokenBranches8323[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8340_16[] = { +Coding x64Parser::tokenCoding8346_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_17[] = { +Coding x64Parser::tokenCoding8346_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_18[] = { +Coding x64Parser::tokenCoding8346_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_19[] = { +Coding x64Parser::tokenCoding8346_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8340(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8346(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8340_16; - operand.values[17] = tokenCoding8340_17; - operand.values[18] = tokenCoding8340_18; - operand.values[19] = tokenCoding8340_19; + operand.values[16] = tokenCoding8346_16; + operand.values[17] = tokenCoding8346_17; + operand.values[18] = tokenCoding8346_18; + operand.values[19] = tokenCoding8346_19; } -x64Token x64Parser::tokenBranches8339[] = { - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8340, }, +x64Token x64Parser::tokenBranches8345[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8346, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) { - operand.operandCoding = 722; + operand.operandCoding = 723; } -x64Token x64Parser::tokenBranches8321[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8322, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339 }, +x64Token x64Parser::tokenBranches8327[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8328, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8345 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8320[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, +x64Token x64Parser::tokenBranches8326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8344_16[] = { +Coding x64Parser::tokenCoding8350_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_17[] = { +Coding x64Parser::tokenCoding8350_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_18[] = { +Coding x64Parser::tokenCoding8350_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_19[] = { +Coding x64Parser::tokenCoding8350_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8344(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8350(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8344_16; - operand.values[17] = tokenCoding8344_17; - operand.values[18] = tokenCoding8344_18; - operand.values[19] = tokenCoding8344_19; + operand.values[16] = tokenCoding8350_16; + operand.values[17] = tokenCoding8350_17; + operand.values[18] = tokenCoding8350_18; + operand.values[19] = tokenCoding8350_19; } -x64Token x64Parser::tokenBranches8343[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8344, }, +x64Token x64Parser::tokenBranches8349[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8350, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8331(x64Operand &operand, int tokenPos) { - operand.operandCoding = 723; + operand.operandCoding = 724; } -x64Token x64Parser::tokenBranches8324[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8325, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343 }, +x64Token x64Parser::tokenBranches8330[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8331, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8323[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, +x64Token x64Parser::tokenBranches8329[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8348_16[] = { +Coding x64Parser::tokenCoding8354_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_17[] = { +Coding x64Parser::tokenCoding8354_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_18[] = { +Coding x64Parser::tokenCoding8354_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_19[] = { +Coding x64Parser::tokenCoding8354_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8348(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8354(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8348_16; - operand.values[17] = tokenCoding8348_17; - operand.values[18] = tokenCoding8348_18; - operand.values[19] = tokenCoding8348_19; + operand.values[16] = tokenCoding8354_16; + operand.values[17] = tokenCoding8354_17; + operand.values[18] = tokenCoding8354_18; + operand.values[19] = tokenCoding8354_19; } -x64Token x64Parser::tokenBranches8347[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8348, }, +x64Token x64Parser::tokenBranches8353[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8354, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8334(x64Operand &operand, int tokenPos) { - operand.operandCoding = 724; + operand.operandCoding = 725; } -x64Token x64Parser::tokenBranches8327[] = { - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8328, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347 }, +x64Token x64Parser::tokenBranches8333[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8334, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8353 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8326[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, +x64Token x64Parser::tokenBranches8332[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8333 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8332_16[] = { +Coding x64Parser::tokenCoding8338_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_17[] = { +Coding x64Parser::tokenCoding8338_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_18[] = { +Coding x64Parser::tokenCoding8338_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_19[] = { +Coding x64Parser::tokenCoding8338_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8338(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8332_16; - operand.values[17] = tokenCoding8332_17; - operand.values[18] = tokenCoding8332_18; - operand.values[19] = tokenCoding8332_19; + operand.values[16] = tokenCoding8338_16; + operand.values[17] = tokenCoding8338_17; + operand.values[18] = tokenCoding8338_18; + operand.values[19] = tokenCoding8338_19; } -x64Token x64Parser::tokenBranches8331[] = { - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8332, }, +x64Token x64Parser::tokenBranches8337[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8338, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8330[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331 }, +x64Token x64Parser::tokenBranches8336[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8337 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8329[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, +x64Token x64Parser::tokenBranches8335[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8336 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8336_16[] = { +Coding x64Parser::tokenCoding8342_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_17[] = { +Coding x64Parser::tokenCoding8342_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_23[] = { +Coding x64Parser::tokenCoding8342_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_18[] = { +Coding x64Parser::tokenCoding8342_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_19[] = { +Coding x64Parser::tokenCoding8342_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8336(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8342(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8336_16; - operand.values[17] = tokenCoding8336_17; - operand.values[23] = tokenCoding8336_23; - operand.values[18] = tokenCoding8336_18; - operand.values[19] = tokenCoding8336_19; + operand.values[16] = tokenCoding8342_16; + operand.values[17] = tokenCoding8342_17; + operand.values[23] = tokenCoding8342_23; + operand.values[18] = tokenCoding8342_18; + operand.values[19] = tokenCoding8342_19; } -x64Token x64Parser::tokenBranches8335[] = { - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8336, }, +x64Token x64Parser::tokenBranches8341[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8342, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8334[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335 }, +x64Token x64Parser::tokenBranches8340[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8341 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8333[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334 }, +x64Token x64Parser::tokenBranches8339[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8340 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8352_16[] = { +Coding x64Parser::tokenCoding8358_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_17[] = { +Coding x64Parser::tokenCoding8358_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_18[] = { +Coding x64Parser::tokenCoding8358_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_19[] = { +Coding x64Parser::tokenCoding8358_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8358(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35020,32 +35089,32 @@ void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8352_16; - operand.values[17] = tokenCoding8352_17; - operand.values[18] = tokenCoding8352_18; - operand.values[19] = tokenCoding8352_19; + operand.values[16] = tokenCoding8358_16; + operand.values[17] = tokenCoding8358_17; + operand.values[18] = tokenCoding8358_18; + operand.values[19] = tokenCoding8358_19; } -Coding x64Parser::tokenCoding8356_16[] = { +Coding x64Parser::tokenCoding8362_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_17[] = { +Coding x64Parser::tokenCoding8362_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_23[] = { +Coding x64Parser::tokenCoding8362_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_18[] = { +Coding x64Parser::tokenCoding8362_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_19[] = { +Coding x64Parser::tokenCoding8362_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8362(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35056,43 +35125,43 @@ void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8356_16; - operand.values[17] = tokenCoding8356_17; - operand.values[23] = tokenCoding8356_23; - operand.values[18] = tokenCoding8356_18; - operand.values[19] = tokenCoding8356_19; + operand.values[16] = tokenCoding8362_16; + operand.values[17] = tokenCoding8362_17; + operand.values[23] = tokenCoding8362_23; + operand.values[18] = tokenCoding8362_18; + operand.values[19] = tokenCoding8362_19; } -x64Token x64Parser::tokenBranches8351[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8352, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8356, }, +x64Token x64Parser::tokenBranches8357[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8358, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8362, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8350[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351 }, +x64Token x64Parser::tokenBranches8356[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8357 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8349[] = { - {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350 }, +x64Token x64Parser::tokenBranches8355[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8356 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8360_16[] = { +Coding x64Parser::tokenCoding8366_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_17[] = { +Coding x64Parser::tokenCoding8366_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_18[] = { +Coding x64Parser::tokenCoding8366_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_19[] = { +Coding x64Parser::tokenCoding8366_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8366(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35103,41 +35172,41 @@ void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8360_16; - operand.values[17] = tokenCoding8360_17; - operand.values[18] = tokenCoding8360_18; - operand.values[19] = tokenCoding8360_19; + operand.values[16] = tokenCoding8366_16; + operand.values[17] = tokenCoding8366_17; + operand.values[18] = tokenCoding8366_18; + operand.values[19] = tokenCoding8366_19; } -x64Token x64Parser::tokenBranches8359[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8360, }, +x64Token x64Parser::tokenBranches8365[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8366, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8358[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359 }, +x64Token x64Parser::tokenBranches8364[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8365 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8357[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358 }, +x64Token x64Parser::tokenBranches8363[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8364 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8364_16[] = { +Coding x64Parser::tokenCoding8370_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_17[] = { +Coding x64Parser::tokenCoding8370_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_18[] = { +Coding x64Parser::tokenCoding8370_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_19[] = { +Coding x64Parser::tokenCoding8370_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8370(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35148,41 +35217,41 @@ void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8364_16; - operand.values[17] = tokenCoding8364_17; - operand.values[18] = tokenCoding8364_18; - operand.values[19] = tokenCoding8364_19; + operand.values[16] = tokenCoding8370_16; + operand.values[17] = tokenCoding8370_17; + operand.values[18] = tokenCoding8370_18; + operand.values[19] = tokenCoding8370_19; } -x64Token x64Parser::tokenBranches8363[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8364, }, +x64Token x64Parser::tokenBranches8369[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8370, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8362[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363 }, +x64Token x64Parser::tokenBranches8368[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8369 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8361[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362 }, +x64Token x64Parser::tokenBranches8367[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8368 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8368_16[] = { +Coding x64Parser::tokenCoding8374_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_17[] = { +Coding x64Parser::tokenCoding8374_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_18[] = { +Coding x64Parser::tokenCoding8374_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_19[] = { +Coding x64Parser::tokenCoding8374_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8374(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35193,24 +35262,24 @@ void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8368_16; - operand.values[17] = tokenCoding8368_17; - operand.values[18] = tokenCoding8368_18; - operand.values[19] = tokenCoding8368_19; + operand.values[16] = tokenCoding8374_16; + operand.values[17] = tokenCoding8374_17; + operand.values[18] = tokenCoding8374_18; + operand.values[19] = tokenCoding8374_19; } -x64Token x64Parser::tokenBranches8367[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8368, }, +x64Token x64Parser::tokenBranches8373[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8374, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8366[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367 }, +x64Token x64Parser::tokenBranches8372[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8365[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366 }, +x64Token x64Parser::tokenBranches8371[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35222,7 +35291,7 @@ void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35234,7 +35303,7 @@ void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35246,7 +35315,7 @@ void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8335(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35258,7 +35327,7 @@ void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8339(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35270,53 +35339,19 @@ void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8310[] = { - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8320, x64Parser::tokenBranches8320 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8323, x64Parser::tokenBranches8323 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8333, x64Parser::tokenBranches8333 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8375(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 725; -} -x64Token x64Parser::tokenBranches8374[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8375, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 727; -} -x64Token x64Parser::tokenBranches8386[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 729; -} -x64Token x64Parser::tokenBranches8398[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8373[] = { - {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374 }, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8372[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, +x64Token x64Parser::tokenBranches8316[] = { + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8320 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8323 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8332, x64Parser::tokenBranches8332 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8335, x64Parser::tokenBranches8335 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8339, x64Parser::tokenBranches8339 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8355 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8363 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8367 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8371 }, {x64Token::EOT } }; void x64Parser::TokenFunc8381(x64Operand &operand, int tokenPos) @@ -35353,7 +35388,41 @@ x64Token x64Parser::tokenBranches8378[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 727; +} +x64Token x64Parser::tokenBranches8386[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 729; +} +x64Token x64Parser::tokenBranches8398[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8411(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 731; +} +x64Token x64Parser::tokenBranches8410[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8411, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8385[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8410 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8384[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8385 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8384(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -35365,174 +35434,174 @@ void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8371[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8378, x64Parser::tokenBranches8378 }, +x64Token x64Parser::tokenBranches8377[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8378 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8384, x64Parser::tokenBranches8384 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8370[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371 }, +x64Token x64Parser::tokenBranches8376[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8377 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8406(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) { - operand.operandCoding = 731; + operand.operandCoding = 732; } -x64Token x64Parser::tokenBranches8369[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370 }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8406, }, +x64Token x64Parser::tokenBranches8375[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8376 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8412, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8410_16[] = { +Coding x64Parser::tokenCoding8416_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_17[] = { +Coding x64Parser::tokenCoding8416_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_18[] = { +Coding x64Parser::tokenCoding8416_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_19[] = { +Coding x64Parser::tokenCoding8416_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8410(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8410_16; - operand.values[17] = tokenCoding8410_17; - operand.values[18] = tokenCoding8410_18; - operand.values[19] = tokenCoding8410_19; + operand.values[16] = tokenCoding8416_16; + operand.values[17] = tokenCoding8416_17; + operand.values[18] = tokenCoding8416_18; + operand.values[19] = tokenCoding8416_19; } -x64Token x64Parser::tokenBranches8409[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8410, }, +x64Token x64Parser::tokenBranches8415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8412_16[] = { +Coding x64Parser::tokenCoding8418_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_17[] = { +Coding x64Parser::tokenCoding8418_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_18[] = { +Coding x64Parser::tokenCoding8418_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_19[] = { +Coding x64Parser::tokenCoding8418_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8418(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8412_16; - operand.values[17] = tokenCoding8412_17; - operand.values[18] = tokenCoding8412_18; - operand.values[19] = tokenCoding8412_19; + operand.values[16] = tokenCoding8418_16; + operand.values[17] = tokenCoding8418_17; + operand.values[18] = tokenCoding8418_18; + operand.values[19] = tokenCoding8418_19; } -x64Token x64Parser::tokenBranches8411[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8412, }, +x64Token x64Parser::tokenBranches8417[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8418, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8414_16[] = { +Coding x64Parser::tokenCoding8420_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_17[] = { +Coding x64Parser::tokenCoding8420_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_18[] = { +Coding x64Parser::tokenCoding8420_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_19[] = { +Coding x64Parser::tokenCoding8420_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8414(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8420(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8414_16; - operand.values[17] = tokenCoding8414_17; - operand.values[18] = tokenCoding8414_18; - operand.values[19] = tokenCoding8414_19; + operand.values[16] = tokenCoding8420_16; + operand.values[17] = tokenCoding8420_17; + operand.values[18] = tokenCoding8420_18; + operand.values[19] = tokenCoding8420_19; } -x64Token x64Parser::tokenBranches8413[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8414, }, +x64Token x64Parser::tokenBranches8419[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8420, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8416_16[] = { +Coding x64Parser::tokenCoding8422_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_17[] = { +Coding x64Parser::tokenCoding8422_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_18[] = { +Coding x64Parser::tokenCoding8422_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_19[] = { +Coding x64Parser::tokenCoding8422_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8422(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8416_16; - operand.values[17] = tokenCoding8416_17; - operand.values[18] = tokenCoding8416_18; - operand.values[19] = tokenCoding8416_19; + operand.values[16] = tokenCoding8422_16; + operand.values[17] = tokenCoding8422_17; + operand.values[18] = tokenCoding8422_18; + operand.values[19] = tokenCoding8422_19; } -x64Token x64Parser::tokenBranches8415[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, +x64Token x64Parser::tokenBranches8421[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8422, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8469_16[] = { +Coding x64Parser::tokenCoding8475_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_17[] = { +Coding x64Parser::tokenCoding8475_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_23[] = { +Coding x64Parser::tokenCoding8475_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_18[] = { +Coding x64Parser::tokenCoding8475_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_19[] = { +Coding x64Parser::tokenCoding8475_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8469(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8475(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8469_16; - operand.values[17] = tokenCoding8469_17; - operand.values[23] = tokenCoding8469_23; - operand.values[18] = tokenCoding8469_18; - operand.values[19] = tokenCoding8469_19; + operand.values[16] = tokenCoding8475_16; + operand.values[17] = tokenCoding8475_17; + operand.values[23] = tokenCoding8475_23; + operand.values[18] = tokenCoding8475_18; + operand.values[19] = tokenCoding8475_19; } -x64Token x64Parser::tokenBranches8468[] = { - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8469, }, +x64Token x64Parser::tokenBranches8474[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8475, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8467[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468 }, +x64Token x64Parser::tokenBranches8473[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8474 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35544,47 +35613,47 @@ void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8466[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8467, x64Parser::tokenBranches8467 }, +x64Token x64Parser::tokenBranches8472[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8473, x64Parser::tokenBranches8473 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8473_16[] = { +Coding x64Parser::tokenCoding8479_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_17[] = { +Coding x64Parser::tokenCoding8479_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_23[] = { +Coding x64Parser::tokenCoding8479_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_18[] = { +Coding x64Parser::tokenCoding8479_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_19[] = { +Coding x64Parser::tokenCoding8479_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8479(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8473_16; - operand.values[17] = tokenCoding8473_17; - operand.values[23] = tokenCoding8473_23; - operand.values[18] = tokenCoding8473_18; - operand.values[19] = tokenCoding8473_19; + operand.values[16] = tokenCoding8479_16; + operand.values[17] = tokenCoding8479_17; + operand.values[23] = tokenCoding8479_23; + operand.values[18] = tokenCoding8479_18; + operand.values[19] = tokenCoding8479_19; } -x64Token x64Parser::tokenBranches8472[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8473, }, +x64Token x64Parser::tokenBranches8478[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8479, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8471[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472 }, +x64Token x64Parser::tokenBranches8477[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8478 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8477(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35596,104 +35665,104 @@ void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8470[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8471, x64Parser::tokenBranches8471 }, +x64Token x64Parser::tokenBranches8476[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8477, x64Parser::tokenBranches8477 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8490_16[] = { +Coding x64Parser::tokenCoding8496_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_17[] = { +Coding x64Parser::tokenCoding8496_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_23[] = { +Coding x64Parser::tokenCoding8496_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_18[] = { +Coding x64Parser::tokenCoding8496_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_19[] = { +Coding x64Parser::tokenCoding8496_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8490(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8490_16; - operand.values[17] = tokenCoding8490_17; - operand.values[23] = tokenCoding8490_23; - operand.values[18] = tokenCoding8490_18; - operand.values[19] = tokenCoding8490_19; + operand.values[16] = tokenCoding8496_16; + operand.values[17] = tokenCoding8496_17; + operand.values[23] = tokenCoding8496_23; + operand.values[18] = tokenCoding8496_18; + operand.values[19] = tokenCoding8496_19; } -x64Token x64Parser::tokenBranches8489[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8490, }, +x64Token x64Parser::tokenBranches8495[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8496, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8488[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489 }, +x64Token x64Parser::tokenBranches8494[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8493_16[] = { +Coding x64Parser::tokenCoding8499_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_17[] = { +Coding x64Parser::tokenCoding8499_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_23[] = { +Coding x64Parser::tokenCoding8499_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_18[] = { +Coding x64Parser::tokenCoding8499_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_19[] = { +Coding x64Parser::tokenCoding8499_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8493(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8493_16; - operand.values[17] = tokenCoding8493_17; - operand.values[23] = tokenCoding8493_23; - operand.values[18] = tokenCoding8493_18; - operand.values[19] = tokenCoding8493_19; + operand.values[16] = tokenCoding8499_16; + operand.values[17] = tokenCoding8499_17; + operand.values[23] = tokenCoding8499_23; + operand.values[18] = tokenCoding8499_18; + operand.values[19] = tokenCoding8499_19; } -x64Token x64Parser::tokenBranches8492[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8493, }, +x64Token x64Parser::tokenBranches8498[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8499, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8491[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492 }, +x64Token x64Parser::tokenBranches8497[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8498 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8496_16[] = { +Coding x64Parser::tokenCoding8502_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_17[] = { +Coding x64Parser::tokenCoding8502_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_23[] = { +Coding x64Parser::tokenCoding8502_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_18[] = { +Coding x64Parser::tokenCoding8502_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_19[] = { +Coding x64Parser::tokenCoding8502_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8502(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35704,34 +35773,34 @@ void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8496_16; - operand.values[17] = tokenCoding8496_17; - operand.values[23] = tokenCoding8496_23; - operand.values[18] = tokenCoding8496_18; - operand.values[19] = tokenCoding8496_19; + operand.values[16] = tokenCoding8502_16; + operand.values[17] = tokenCoding8502_17; + operand.values[23] = tokenCoding8502_23; + operand.values[18] = tokenCoding8502_18; + operand.values[19] = tokenCoding8502_19; } -Coding x64Parser::tokenCoding8499_16[] = { +Coding x64Parser::tokenCoding8505_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_17[] = { +Coding x64Parser::tokenCoding8505_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_23[] = { +Coding x64Parser::tokenCoding8505_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_18[] = { +Coding x64Parser::tokenCoding8505_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_19[] = { +Coding x64Parser::tokenCoding8505_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8505(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35742,22 +35811,22 @@ void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8499_16; - operand.values[17] = tokenCoding8499_17; - operand.values[23] = tokenCoding8499_23; - operand.values[18] = tokenCoding8499_18; - operand.values[19] = tokenCoding8499_19; + operand.values[16] = tokenCoding8505_16; + operand.values[17] = tokenCoding8505_17; + operand.values[23] = tokenCoding8505_23; + operand.values[18] = tokenCoding8505_18; + operand.values[19] = tokenCoding8505_19; } -x64Token x64Parser::tokenBranches8495[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8496, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8499, }, +x64Token x64Parser::tokenBranches8501[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8502, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8505, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8494[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, +x64Token x64Parser::tokenBranches8500[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8494(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35769,7 +35838,7 @@ void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8497(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35781,33 +35850,33 @@ void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8487[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8488, x64Parser::tokenBranches8488 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8491, x64Parser::tokenBranches8491 }, - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494 }, +x64Token x64Parser::tokenBranches8493[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8494, x64Parser::tokenBranches8494 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8497, x64Parser::tokenBranches8497 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8500 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8503_16[] = { +Coding x64Parser::tokenCoding8509_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_17[] = { +Coding x64Parser::tokenCoding8509_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_23[] = { +Coding x64Parser::tokenCoding8509_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_18[] = { +Coding x64Parser::tokenCoding8509_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_19[] = { +Coding x64Parser::tokenCoding8509_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35818,160 +35887,123 @@ void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8503_16; - operand.values[17] = tokenCoding8503_17; - operand.values[23] = tokenCoding8503_23; - operand.values[18] = tokenCoding8503_18; - operand.values[19] = tokenCoding8503_19; + operand.values[16] = tokenCoding8509_16; + operand.values[17] = tokenCoding8509_17; + operand.values[23] = tokenCoding8509_23; + operand.values[18] = tokenCoding8509_18; + operand.values[19] = tokenCoding8509_19; } -x64Token x64Parser::tokenBranches8502[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8503, }, +x64Token x64Parser::tokenBranches8508[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8509, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8501[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502 }, +x64Token x64Parser::tokenBranches8507[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8506_16[] = { +Coding x64Parser::tokenCoding8512_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_17[] = { +Coding x64Parser::tokenCoding8512_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_23[] = { +Coding x64Parser::tokenCoding8512_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_18[] = { +Coding x64Parser::tokenCoding8512_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_19[] = { +Coding x64Parser::tokenCoding8512_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8506(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8506_16; - operand.values[17] = tokenCoding8506_17; - operand.values[23] = tokenCoding8506_23; - operand.values[18] = tokenCoding8506_18; - operand.values[19] = tokenCoding8506_19; + operand.values[16] = tokenCoding8512_16; + operand.values[17] = tokenCoding8512_17; + operand.values[23] = tokenCoding8512_23; + operand.values[18] = tokenCoding8512_18; + operand.values[19] = tokenCoding8512_19; } -x64Token x64Parser::tokenBranches8505[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8506, }, +x64Token x64Parser::tokenBranches8511[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8504[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505 }, +x64Token x64Parser::tokenBranches8510[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8511 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8509_16[] = { +Coding x64Parser::tokenCoding8515_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_17[] = { +Coding x64Parser::tokenCoding8515_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_23[] = { +Coding x64Parser::tokenCoding8515_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_18[] = { +Coding x64Parser::tokenCoding8515_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_19[] = { +Coding x64Parser::tokenCoding8515_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8509_16; - operand.values[17] = tokenCoding8509_17; - operand.values[23] = tokenCoding8509_23; - operand.values[18] = tokenCoding8509_18; - operand.values[19] = tokenCoding8509_19; + operand.values[16] = tokenCoding8515_16; + operand.values[17] = tokenCoding8515_17; + operand.values[23] = tokenCoding8515_23; + operand.values[18] = tokenCoding8515_18; + operand.values[19] = tokenCoding8515_19; } -Coding x64Parser::tokenCoding8512_16[] = { +Coding x64Parser::tokenCoding8518_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_17[] = { +Coding x64Parser::tokenCoding8518_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_23[] = { +Coding x64Parser::tokenCoding8518_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_18[] = { +Coding x64Parser::tokenCoding8518_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_19[] = { +Coding x64Parser::tokenCoding8518_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8512_16; - operand.values[17] = tokenCoding8512_17; - operand.values[23] = tokenCoding8512_23; - operand.values[18] = tokenCoding8512_18; - operand.values[19] = tokenCoding8512_19; + operand.values[16] = tokenCoding8518_16; + operand.values[17] = tokenCoding8518_17; + operand.values[23] = tokenCoding8518_23; + operand.values[18] = tokenCoding8518_18; + operand.values[19] = tokenCoding8518_19; } -x64Token x64Parser::tokenBranches8508[] = { - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8509, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, +x64Token x64Parser::tokenBranches8514[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8515, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8518, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8507[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, +x64Token x64Parser::tokenBranches8513[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8515_16[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_17[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_18[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_19[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8515_16; - operand.values[17] = tokenCoding8515_17; - operand.values[23] = tokenCoding8515_23; - operand.values[18] = tokenCoding8515_18; - operand.values[19] = tokenCoding8515_19; -} Coding x64Parser::tokenCoding8521_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, @@ -35981,7 +36013,6 @@ Coding x64Parser::tokenCoding8521_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_23[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_18[] = { @@ -36010,36 +36041,28 @@ void x64Parser::TokenFunc8521(x64Operand &operand, int tokenPos) operand.values[18] = tokenCoding8521_18; operand.values[19] = tokenCoding8521_19; } -x64Token x64Parser::tokenBranches8514[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8515, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8521, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8513[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8518_16[] = { +Coding x64Parser::tokenCoding8527_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_17[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, +Coding x64Parser::tokenCoding8527_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_23[] = { +Coding x64Parser::tokenCoding8527_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_18[] = { +Coding x64Parser::tokenCoding8527_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_19[] = { +Coding x64Parser::tokenCoding8527_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8527(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36050,12 +36073,21 @@ void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8518_16; - operand.values[17] = tokenCoding8518_17; - operand.values[23] = tokenCoding8518_23; - operand.values[18] = tokenCoding8518_18; - operand.values[19] = tokenCoding8518_19; + operand.values[16] = tokenCoding8527_16; + operand.values[17] = tokenCoding8527_17; + operand.values[23] = tokenCoding8527_23; + operand.values[18] = tokenCoding8527_18; + operand.values[19] = tokenCoding8527_19; } +x64Token x64Parser::tokenBranches8520[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8521, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8527, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8519[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8520 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8524_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, @@ -36065,7 +36097,6 @@ Coding x64Parser::tokenCoding8524_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_23[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_18[] = { @@ -36074,7 +36105,7 @@ Coding x64Parser::tokenCoding8524_18[] = { }; Coding x64Parser::tokenCoding8524_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) @@ -36094,16 +36125,54 @@ void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) operand.values[18] = tokenCoding8524_18; operand.values[19] = tokenCoding8524_19; } -x64Token x64Parser::tokenBranches8517[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8518, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8524, }, +Coding x64Parser::tokenCoding8530_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8530_16; + operand.values[17] = tokenCoding8530_17; + operand.values[23] = tokenCoding8530_23; + operand.values[18] = tokenCoding8530_18; + operand.values[19] = tokenCoding8530_19; +} +x64Token x64Parser::tokenBranches8523[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8524, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8530, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8516[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517 }, +x64Token x64Parser::tokenBranches8522[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8523 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8510(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36115,7 +36184,7 @@ void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8513(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36127,51 +36196,51 @@ void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8500[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8504, x64Parser::tokenBranches8504 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8507, x64Parser::tokenBranches8507 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513 }, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516 }, +x64Token x64Parser::tokenBranches8506[] = { + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8507 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8510, x64Parser::tokenBranches8510 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8513, x64Parser::tokenBranches8513 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8519 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8522 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8532_16[] = { +Coding x64Parser::tokenCoding8538_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_17[] = { +Coding x64Parser::tokenCoding8538_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_23[] = { +Coding x64Parser::tokenCoding8538_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_18[] = { +Coding x64Parser::tokenCoding8538_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_19[] = { +Coding x64Parser::tokenCoding8538_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8532(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8532_16; - operand.values[17] = tokenCoding8532_17; - operand.values[23] = tokenCoding8532_23; - operand.values[18] = tokenCoding8532_18; - operand.values[19] = tokenCoding8532_19; + operand.values[16] = tokenCoding8538_16; + operand.values[17] = tokenCoding8538_17; + operand.values[23] = tokenCoding8538_23; + operand.values[18] = tokenCoding8538_18; + operand.values[19] = tokenCoding8538_19; } -x64Token x64Parser::tokenBranches8531[] = { - {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8532, }, +x64Token x64Parser::tokenBranches8537[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8530[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531 }, +x64Token x64Parser::tokenBranches8536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36183,47 +36252,47 @@ void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8529[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8530, x64Parser::tokenBranches8530 }, +x64Token x64Parser::tokenBranches8535[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8538_16[] = { +Coding x64Parser::tokenCoding8544_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_17[] = { +Coding x64Parser::tokenCoding8544_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_23[] = { +Coding x64Parser::tokenCoding8544_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_18[] = { +Coding x64Parser::tokenCoding8544_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_19[] = { +Coding x64Parser::tokenCoding8544_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8544(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8538_16; - operand.values[17] = tokenCoding8538_17; - operand.values[23] = tokenCoding8538_23; - operand.values[18] = tokenCoding8538_18; - operand.values[19] = tokenCoding8538_19; + operand.values[16] = tokenCoding8544_16; + operand.values[17] = tokenCoding8544_17; + operand.values[23] = tokenCoding8544_23; + operand.values[18] = tokenCoding8544_18; + operand.values[19] = tokenCoding8544_19; } -x64Token x64Parser::tokenBranches8537[] = { - {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, +x64Token x64Parser::tokenBranches8543[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8544, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8536[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, +x64Token x64Parser::tokenBranches8542[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8543 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8542(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36235,32 +36304,32 @@ void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8535[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, +x64Token x64Parser::tokenBranches8541[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8542, x64Parser::tokenBranches8542 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8546_16[] = { +Coding x64Parser::tokenCoding8552_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_17[] = { +Coding x64Parser::tokenCoding8552_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_23[] = { +Coding x64Parser::tokenCoding8552_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_18[] = { +Coding x64Parser::tokenCoding8552_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_19[] = { +Coding x64Parser::tokenCoding8552_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8552(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36271,37 +36340,37 @@ void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8546_16; - operand.values[17] = tokenCoding8546_17; - operand.values[23] = tokenCoding8546_23; - operand.values[18] = tokenCoding8546_18; - operand.values[19] = tokenCoding8546_19; + operand.values[16] = tokenCoding8552_16; + operand.values[17] = tokenCoding8552_17; + operand.values[23] = tokenCoding8552_23; + operand.values[18] = tokenCoding8552_18; + operand.values[19] = tokenCoding8552_19; } -x64Token x64Parser::tokenBranches8545[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8546, }, +x64Token x64Parser::tokenBranches8551[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8552, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8544[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545 }, +x64Token x64Parser::tokenBranches8550[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8551 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8543[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544 }, +x64Token x64Parser::tokenBranches8549[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8550 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8550_16[] = { +Coding x64Parser::tokenCoding8556_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8550_17[] = { +Coding x64Parser::tokenCoding8556_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8550_18[] = { +Coding x64Parser::tokenCoding8556_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8556(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36312,23 +36381,23 @@ void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8550_16; - operand.values[17] = tokenCoding8550_17; - operand.values[18] = tokenCoding8550_18; + operand.values[16] = tokenCoding8556_16; + operand.values[17] = tokenCoding8556_17; + operand.values[18] = tokenCoding8556_18; } -Coding x64Parser::tokenCoding8553_16[] = { +Coding x64Parser::tokenCoding8559_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8553_17[] = { +Coding x64Parser::tokenCoding8559_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8553_18[] = { +Coding x64Parser::tokenCoding8559_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8559(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36339,45 +36408,45 @@ void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8553_16; - operand.values[17] = tokenCoding8553_17; - operand.values[18] = tokenCoding8553_18; + operand.values[16] = tokenCoding8559_16; + operand.values[17] = tokenCoding8559_17; + operand.values[18] = tokenCoding8559_18; } -x64Token x64Parser::tokenBranches8549[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8550, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8553, }, +x64Token x64Parser::tokenBranches8555[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8556, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8559, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8548[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549 }, +x64Token x64Parser::tokenBranches8554[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8547[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548 }, +x64Token x64Parser::tokenBranches8553[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8554 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8557_16[] = { +Coding x64Parser::tokenCoding8563_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_17[] = { +Coding x64Parser::tokenCoding8563_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_23[] = { +Coding x64Parser::tokenCoding8563_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_18[] = { +Coding x64Parser::tokenCoding8563_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_19[] = { +Coding x64Parser::tokenCoding8563_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8563(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36388,45 +36457,45 @@ void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8557_16; - operand.values[17] = tokenCoding8557_17; - operand.values[23] = tokenCoding8557_23; - operand.values[18] = tokenCoding8557_18; - operand.values[19] = tokenCoding8557_19; + operand.values[16] = tokenCoding8563_16; + operand.values[17] = tokenCoding8563_17; + operand.values[23] = tokenCoding8563_23; + operand.values[18] = tokenCoding8563_18; + operand.values[19] = tokenCoding8563_19; } -x64Token x64Parser::tokenBranches8556[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8557, }, +x64Token x64Parser::tokenBranches8562[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8563, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8555[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556 }, +x64Token x64Parser::tokenBranches8561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8562 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8554[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, +x64Token x64Parser::tokenBranches8560[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8561 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8561_16[] = { +Coding x64Parser::tokenCoding8567_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_17[] = { +Coding x64Parser::tokenCoding8567_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_23[] = { +Coding x64Parser::tokenCoding8567_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_18[] = { +Coding x64Parser::tokenCoding8567_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_19[] = { +Coding x64Parser::tokenCoding8567_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36437,45 +36506,45 @@ void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8561_16; - operand.values[17] = tokenCoding8561_17; - operand.values[23] = tokenCoding8561_23; - operand.values[18] = tokenCoding8561_18; - operand.values[19] = tokenCoding8561_19; + operand.values[16] = tokenCoding8567_16; + operand.values[17] = tokenCoding8567_17; + operand.values[23] = tokenCoding8567_23; + operand.values[18] = tokenCoding8567_18; + operand.values[19] = tokenCoding8567_19; } -x64Token x64Parser::tokenBranches8560[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8561, }, +x64Token x64Parser::tokenBranches8566[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8567, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8559[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560 }, +x64Token x64Parser::tokenBranches8565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8566 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8558[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559 }, +x64Token x64Parser::tokenBranches8564[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8565 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8565_16[] = { +Coding x64Parser::tokenCoding8571_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_17[] = { +Coding x64Parser::tokenCoding8571_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_23[] = { +Coding x64Parser::tokenCoding8571_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_18[] = { +Coding x64Parser::tokenCoding8571_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_19[] = { +Coding x64Parser::tokenCoding8571_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8571(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36486,62 +36555,62 @@ void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8565_16; - operand.values[17] = tokenCoding8565_17; - operand.values[23] = tokenCoding8565_23; - operand.values[18] = tokenCoding8565_18; - operand.values[19] = tokenCoding8565_19; + operand.values[16] = tokenCoding8571_16; + operand.values[17] = tokenCoding8571_17; + operand.values[23] = tokenCoding8571_23; + operand.values[18] = tokenCoding8571_18; + operand.values[19] = tokenCoding8571_19; } -x64Token x64Parser::tokenBranches8564[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8565, }, +x64Token x64Parser::tokenBranches8570[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8571, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8563[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564 }, +x64Token x64Parser::tokenBranches8569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8570 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8562[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563 }, +x64Token x64Parser::tokenBranches8568[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8569 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8569_16[] = { +Coding x64Parser::tokenCoding8575_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_17[] = { +Coding x64Parser::tokenCoding8575_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_23[] = { +Coding x64Parser::tokenCoding8575_23[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_18[] = { +Coding x64Parser::tokenCoding8575_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_19[] = { +Coding x64Parser::tokenCoding8575_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8569(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8575(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8569_16; - operand.values[17] = tokenCoding8569_17; - operand.values[23] = tokenCoding8569_23; - operand.values[18] = tokenCoding8569_18; - operand.values[19] = tokenCoding8569_19; + operand.values[16] = tokenCoding8575_16; + operand.values[17] = tokenCoding8575_17; + operand.values[23] = tokenCoding8575_23; + operand.values[18] = tokenCoding8575_18; + operand.values[19] = tokenCoding8575_19; } -x64Token x64Parser::tokenBranches8568[] = { - {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8569, }, +x64Token x64Parser::tokenBranches8574[] = { + {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8575, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8567[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568 }, +x64Token x64Parser::tokenBranches8573[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8574 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8573(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36553,26 +36622,26 @@ void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8566[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8567, x64Parser::tokenBranches8567 }, +x64Token x64Parser::tokenBranches8572[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8573, x64Parser::tokenBranches8573 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8597_16[] = { +Coding x64Parser::tokenCoding8603_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_17[] = { +Coding x64Parser::tokenCoding8603_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_23[] = { +Coding x64Parser::tokenCoding8603_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_18[] = { +Coding x64Parser::tokenCoding8603_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8603(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36585,44 +36654,44 @@ void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8597_16; - operand.values[17] = tokenCoding8597_17; - operand.values[23] = tokenCoding8597_23; - operand.values[18] = tokenCoding8597_18; + operand.values[16] = tokenCoding8603_16; + operand.values[17] = tokenCoding8603_17; + operand.values[23] = tokenCoding8603_23; + operand.values[18] = tokenCoding8603_18; } -x64Token x64Parser::tokenBranches8596[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8597, }, +x64Token x64Parser::tokenBranches8602[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8603, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8595[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596 }, +x64Token x64Parser::tokenBranches8601[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8602 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8594[] = { - {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595 }, +x64Token x64Parser::tokenBranches8600[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8593[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594 }, +x64Token x64Parser::tokenBranches8599[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8602_16[] = { +Coding x64Parser::tokenCoding8608_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_17[] = { +Coding x64Parser::tokenCoding8608_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_23[] = { +Coding x64Parser::tokenCoding8608_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_18[] = { +Coding x64Parser::tokenCoding8608_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8608(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36635,28 +36704,28 @@ void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8602_16; - operand.values[17] = tokenCoding8602_17; - operand.values[23] = tokenCoding8602_23; - operand.values[18] = tokenCoding8602_18; + operand.values[16] = tokenCoding8608_16; + operand.values[17] = tokenCoding8608_17; + operand.values[23] = tokenCoding8608_23; + operand.values[18] = tokenCoding8608_18; } -x64Token x64Parser::tokenBranches8601[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8602, }, +x64Token x64Parser::tokenBranches8607[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8608, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8600[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, +x64Token x64Parser::tokenBranches8606[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8607 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8599[] = { - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, +x64Token x64Parser::tokenBranches8605[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8606 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8598[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599 }, +x64Token x64Parser::tokenBranches8604[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8605 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8599(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36668,66 +36737,7 @@ void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8598(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8592[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8593, x64Parser::tokenBranches8593 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8598, x64Parser::tokenBranches8598 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8621_16[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_18[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc8621(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8621_16; - operand.values[17] = tokenCoding8621_17; - operand.values[23] = tokenCoding8621_23; - operand.values[18] = tokenCoding8621_18; -} -x64Token x64Parser::tokenBranches8620[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8621, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8619[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8604(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36739,16 +36749,9 @@ void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8618[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8619, x64Parser::tokenBranches8619 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8617[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8616[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617 }, +x64Token x64Parser::tokenBranches8598[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8599, x64Parser::tokenBranches8599 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8604, x64Parser::tokenBranches8604 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8627_16[] = { @@ -36822,7 +36825,7 @@ Coding x64Parser::tokenCoding8633_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_23[] = { @@ -36880,7 +36883,7 @@ x64Token x64Parser::tokenBranches8629[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8628[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8639_16[] = { @@ -36888,21 +36891,17 @@ Coding x64Parser::tokenCoding8639_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8639_19[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -36920,7 +36919,6 @@ void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8639_17; operand.values[23] = tokenCoding8639_23; operand.values[18] = tokenCoding8639_18; - operand.values[19] = tokenCoding8639_19; } x64Token x64Parser::tokenBranches8638[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8639, }, @@ -36943,35 +36941,38 @@ void x64Parser::TokenFunc8637(x64Operand &operand, int tokenPos) operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8636[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8635[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8644_16[] = { +x64Token x64Parser::tokenBranches8634[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8645_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_17[] = { +Coding x64Parser::tokenCoding8645_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding8645_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_18[] = { +Coding x64Parser::tokenCoding8645_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_19[] = { +Coding x64Parser::tokenCoding8645_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36984,50 +36985,62 @@ void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8644_16; - operand.values[17] = tokenCoding8644_17; - operand.values[23] = tokenCoding8644_23; - operand.values[18] = tokenCoding8644_18; - operand.values[19] = tokenCoding8644_19; + operand.values[16] = tokenCoding8645_16; + operand.values[17] = tokenCoding8645_17; + operand.values[23] = tokenCoding8645_23; + operand.values[18] = tokenCoding8645_18; + operand.values[19] = tokenCoding8645_19; } +x64Token x64Parser::tokenBranches8644[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8645, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8643[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8644, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8644 }, {x64Token::EOT } }; +void x64Parser::TokenFunc8643(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} x64Token x64Parser::tokenBranches8642[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8643, x64Parser::tokenBranches8643 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8641[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8640[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8649_16[] = { +Coding x64Parser::tokenCoding8650_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_17[] = { +Coding x64Parser::tokenCoding8650_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_23[] = { +Coding x64Parser::tokenCoding8650_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_18[] = { +Coding x64Parser::tokenCoding8650_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_19[] = { +Coding x64Parser::tokenCoding8650_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8650(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37040,51 +37053,50 @@ void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8649_16; - operand.values[17] = tokenCoding8649_17; - operand.values[23] = tokenCoding8649_23; - operand.values[18] = tokenCoding8649_18; - operand.values[19] = tokenCoding8649_19; + operand.values[16] = tokenCoding8650_16; + operand.values[17] = tokenCoding8650_17; + operand.values[23] = tokenCoding8650_23; + operand.values[18] = tokenCoding8650_18; + operand.values[19] = tokenCoding8650_19; } +x64Token x64Parser::tokenBranches8649[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8650, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8648[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8649, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8649 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8647[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8646[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8645[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8654_16[] = { +Coding x64Parser::tokenCoding8655_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_17[] = { +Coding x64Parser::tokenCoding8655_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_23[] = { +Coding x64Parser::tokenCoding8655_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_18[] = { +Coding x64Parser::tokenCoding8655_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_19[] = { +Coding x64Parser::tokenCoding8655_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8655(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37097,69 +37109,26 @@ void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8654_16; - operand.values[17] = tokenCoding8654_17; - operand.values[23] = tokenCoding8654_23; - operand.values[18] = tokenCoding8654_18; - operand.values[19] = tokenCoding8654_19; + operand.values[16] = tokenCoding8655_16; + operand.values[17] = tokenCoding8655_17; + operand.values[23] = tokenCoding8655_23; + operand.values[18] = tokenCoding8655_18; + operand.values[19] = tokenCoding8655_19; } +x64Token x64Parser::tokenBranches8654[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8655, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8653[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8654, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8654 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8652[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8652(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} x64Token x64Parser::tokenBranches8651[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8652, x64Parser::tokenBranches8652 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8650[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8640(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8634[] = { - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8640, x64Parser::tokenBranches8640 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8645, x64Parser::tokenBranches8645 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8652 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8660_16[] = { @@ -37178,6 +37147,12 @@ Coding x64Parser::tokenCoding8660_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; +Coding x64Parser::tokenCoding8660_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -37195,6 +37170,7 @@ void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8660_17; operand.values[23] = tokenCoding8660_23; operand.values[18] = tokenCoding8660_18; + operand.values[19] = tokenCoding8660_19; } x64Token x64Parser::tokenBranches8659[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8660, }, @@ -37204,15 +37180,27 @@ x64Token x64Parser::tokenBranches8658[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659 }, {x64Token::EOT } }; +void x64Parser::TokenFunc8658(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} x64Token x64Parser::tokenBranches8657[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8658, x64Parser::tokenBranches8658 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8656[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8646(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37224,8 +37212,23 @@ void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8655[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8656, x64Parser::tokenBranches8656 }, +void x64Parser::TokenFunc8651(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8640[] = { + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8646, x64Parser::tokenBranches8646 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8651, x64Parser::tokenBranches8651 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8656 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8666_16[] = { @@ -37299,7 +37302,7 @@ Coding x64Parser::tokenCoding8672_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_23[] = { @@ -37337,7 +37340,7 @@ x64Token x64Parser::tokenBranches8670[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8669[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8668[] = { @@ -37365,21 +37368,17 @@ Coding x64Parser::tokenCoding8678_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8678_19[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -37397,7 +37396,6 @@ void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8678_17; operand.values[23] = tokenCoding8678_23; operand.values[18] = tokenCoding8678_18; - operand.values[19] = tokenCoding8678_19; } x64Token x64Parser::tokenBranches8677[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8678, }, @@ -37408,35 +37406,50 @@ x64Token x64Parser::tokenBranches8676[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8675[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8674[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8683_16[] = { +void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8673[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8684_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_17[] = { +Coding x64Parser::tokenCoding8684_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding8684_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_18[] = { +Coding x64Parser::tokenCoding8684_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_19[] = { +Coding x64Parser::tokenCoding8684_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8684(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37449,42 +37462,50 @@ void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8683_16; - operand.values[17] = tokenCoding8683_17; - operand.values[23] = tokenCoding8683_23; - operand.values[18] = tokenCoding8683_18; - operand.values[19] = tokenCoding8683_19; + operand.values[16] = tokenCoding8684_16; + operand.values[17] = tokenCoding8684_17; + operand.values[23] = tokenCoding8684_23; + operand.values[18] = tokenCoding8684_18; + operand.values[19] = tokenCoding8684_19; } +x64Token x64Parser::tokenBranches8683[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8684, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8682[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8683, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8683 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8681[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8680[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8688_16[] = { +Coding x64Parser::tokenCoding8689_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, +Coding x64Parser::tokenCoding8689_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_23[] = { +Coding x64Parser::tokenCoding8689_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_18[] = { +Coding x64Parser::tokenCoding8689_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_19[] = { +Coding x64Parser::tokenCoding8689_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8689(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37497,42 +37518,90 @@ void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8688_16; - operand.values[17] = tokenCoding8688_17; - operand.values[23] = tokenCoding8688_23; - operand.values[18] = tokenCoding8688_18; - operand.values[19] = tokenCoding8688_19; + operand.values[16] = tokenCoding8689_16; + operand.values[17] = tokenCoding8689_17; + operand.values[23] = tokenCoding8689_23; + operand.values[18] = tokenCoding8689_18; + operand.values[19] = tokenCoding8689_19; } +x64Token x64Parser::tokenBranches8688[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8689, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8687[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8688, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8688 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8686[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, +Coding x64Parser::tokenCoding8694_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8694(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8694_16; + operand.values[17] = tokenCoding8694_17; + operand.values[23] = tokenCoding8694_23; + operand.values[18] = tokenCoding8694_18; + operand.values[19] = tokenCoding8694_19; +} +x64Token x64Parser::tokenBranches8693[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8694, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8693_16[] = { +x64Token x64Parser::tokenBranches8692[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8693 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8699_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_17[] = { +Coding x64Parser::tokenCoding8699_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_23[] = { +Coding x64Parser::tokenCoding8699_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_18[] = { +Coding x64Parser::tokenCoding8699_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_19[] = { +Coding x64Parser::tokenCoding8699_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8699(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37545,31 +37614,31 @@ void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8693_16; - operand.values[17] = tokenCoding8693_17; - operand.values[23] = tokenCoding8693_23; - operand.values[18] = tokenCoding8693_18; - operand.values[19] = tokenCoding8693_19; + operand.values[16] = tokenCoding8699_16; + operand.values[17] = tokenCoding8699_17; + operand.values[23] = tokenCoding8699_23; + operand.values[18] = tokenCoding8699_18; + operand.values[19] = tokenCoding8699_19; } -x64Token x64Parser::tokenBranches8692[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8693, }, +x64Token x64Parser::tokenBranches8698[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8699, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8691[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, +x64Token x64Parser::tokenBranches8697[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8698 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8680[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691 }, +x64Token x64Parser::tokenBranches8686[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8697 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8679[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680 }, +x64Token x64Parser::tokenBranches8685[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8680(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37581,7 +37650,7 @@ void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8685(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37593,120 +37662,120 @@ void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8673[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8679, x64Parser::tokenBranches8679 }, +x64Token x64Parser::tokenBranches8679[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8680, x64Parser::tokenBranches8680 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8685, x64Parser::tokenBranches8685 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8702_16[] = { +Coding x64Parser::tokenCoding8708_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_17[] = { +Coding x64Parser::tokenCoding8708_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_23[] = { +Coding x64Parser::tokenCoding8708_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_18[] = { +Coding x64Parser::tokenCoding8708_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8702(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8702_16; - operand.values[17] = tokenCoding8702_17; - operand.values[23] = tokenCoding8702_23; - operand.values[18] = tokenCoding8702_18; + operand.values[16] = tokenCoding8708_16; + operand.values[17] = tokenCoding8708_17; + operand.values[23] = tokenCoding8708_23; + operand.values[18] = tokenCoding8708_18; } -Coding x64Parser::tokenCoding8708_16[] = { +Coding x64Parser::tokenCoding8714_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_17[] = { +Coding x64Parser::tokenCoding8714_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_23[] = { +Coding x64Parser::tokenCoding8714_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_18[] = { +Coding x64Parser::tokenCoding8714_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8714(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8708_16; - operand.values[17] = tokenCoding8708_17; - operand.values[23] = tokenCoding8708_23; - operand.values[18] = tokenCoding8708_18; + operand.values[16] = tokenCoding8714_16; + operand.values[17] = tokenCoding8714_17; + operand.values[23] = tokenCoding8714_23; + operand.values[18] = tokenCoding8714_18; } -x64Token x64Parser::tokenBranches8701[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8702, }, - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8708, }, +x64Token x64Parser::tokenBranches8707[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8708, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8714, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8700[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701 }, +x64Token x64Parser::tokenBranches8706[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8707 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8705_16[] = { +Coding x64Parser::tokenCoding8711_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_17[] = { +Coding x64Parser::tokenCoding8711_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_23[] = { +Coding x64Parser::tokenCoding8711_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_18[] = { +Coding x64Parser::tokenCoding8711_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8705(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8705_16; - operand.values[17] = tokenCoding8705_17; - operand.values[23] = tokenCoding8705_23; - operand.values[18] = tokenCoding8705_18; + operand.values[16] = tokenCoding8711_16; + operand.values[17] = tokenCoding8711_17; + operand.values[23] = tokenCoding8711_23; + operand.values[18] = tokenCoding8711_18; } -Coding x64Parser::tokenCoding8711_16[] = { +Coding x64Parser::tokenCoding8717_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_17[] = { +Coding x64Parser::tokenCoding8717_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_23[] = { +Coding x64Parser::tokenCoding8717_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_18[] = { +Coding x64Parser::tokenCoding8717_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8717(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8711_16; - operand.values[17] = tokenCoding8711_17; - operand.values[23] = tokenCoding8711_23; - operand.values[18] = tokenCoding8711_18; + operand.values[16] = tokenCoding8717_16; + operand.values[17] = tokenCoding8717_17; + operand.values[23] = tokenCoding8717_23; + operand.values[18] = tokenCoding8717_18; } -x64Token x64Parser::tokenBranches8704[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8705, }, - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8711, }, +x64Token x64Parser::tokenBranches8710[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8711, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8717, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8703[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704 }, +x64Token x64Parser::tokenBranches8709[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8710 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8706(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37718,7 +37787,7 @@ void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8709(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37730,24 +37799,24 @@ void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8699[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8700, x64Parser::tokenBranches8700 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8703, x64Parser::tokenBranches8703 }, +x64Token x64Parser::tokenBranches8705[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8706, x64Parser::tokenBranches8706 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8709, x64Parser::tokenBranches8709 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8725_16[] = { +Coding x64Parser::tokenCoding8731_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8725_17[] = { +Coding x64Parser::tokenCoding8731_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8725_18[] = { +Coding x64Parser::tokenCoding8731_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8731(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37760,27 +37829,27 @@ void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8725_16; - operand.values[17] = tokenCoding8725_17; - operand.values[18] = tokenCoding8725_18; + operand.values[16] = tokenCoding8731_16; + operand.values[17] = tokenCoding8731_17; + operand.values[18] = tokenCoding8731_18; } -x64Token x64Parser::tokenBranches8724[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8725, }, +x64Token x64Parser::tokenBranches8730[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8731, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8723[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724 }, +x64Token x64Parser::tokenBranches8729[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8730 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8722[] = { - {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723 }, +x64Token x64Parser::tokenBranches8728[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8721[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722 }, +x64Token x64Parser::tokenBranches8727[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8727(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37792,23 +37861,23 @@ void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8720[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8721, x64Parser::tokenBranches8721 }, +x64Token x64Parser::tokenBranches8726[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8727, x64Parser::tokenBranches8727 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8730_16[] = { +Coding x64Parser::tokenCoding8736_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8730_17[] = { +Coding x64Parser::tokenCoding8736_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8730_18[] = { +Coding x64Parser::tokenCoding8736_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8736(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37821,35 +37890,35 @@ void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8730_16; - operand.values[17] = tokenCoding8730_17; - operand.values[18] = tokenCoding8730_18; + operand.values[16] = tokenCoding8736_16; + operand.values[17] = tokenCoding8736_17; + operand.values[18] = tokenCoding8736_18; } -x64Token x64Parser::tokenBranches8729[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8730, }, +x64Token x64Parser::tokenBranches8735[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8736, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8728[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, +x64Token x64Parser::tokenBranches8734[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8735 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8727[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, +x64Token x64Parser::tokenBranches8733[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8734 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8739_16[] = { +Coding x64Parser::tokenCoding8745_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8739_17[] = { +Coding x64Parser::tokenCoding8745_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8739_18[] = { +Coding x64Parser::tokenCoding8745_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8745(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37862,20 +37931,20 @@ void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8739_16; - operand.values[17] = tokenCoding8739_17; - operand.values[18] = tokenCoding8739_18; + operand.values[16] = tokenCoding8745_16; + operand.values[17] = tokenCoding8745_17; + operand.values[18] = tokenCoding8745_18; } -x64Token x64Parser::tokenBranches8738[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8739, }, +x64Token x64Parser::tokenBranches8744[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8745, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8737[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738 }, +x64Token x64Parser::tokenBranches8743[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8744 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8736[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737 }, +x64Token x64Parser::tokenBranches8742[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8743 }, {x64Token::EOT } }; asmError x64Parser::Opcode0(x64Operand &operand) @@ -38923,1166 +38992,1166 @@ asmError x64Parser::Opcode97(x64Operand &operand) asmError rv = ParseOperands(tokenBranches6245, operand); return rv; } -Coding x64Parser::OpcodeCodings98_19[] = { +asmError x64Parser::Opcode98(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6248, operand); + return rv; +} +asmError x64Parser::Opcode99(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6251, operand); + return rv; +} +Coding x64Parser::OpcodeCodings100_19[] = { { CODING_NAME("cwd") Coding::stateFunc, 4 }, { CODING_NAME("cwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode98(x64Operand &operand) +asmError x64Parser::Opcode100(x64Operand &operand) { - operand.values[19] = OpcodeCodings98_19; + operand.values[19] = OpcodeCodings100_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings99_19[] = { +Coding x64Parser::OpcodeCodings101_19[] = { { CODING_NAME("cwde") Coding::stateFunc, 5 }, { CODING_NAME("cwde") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode99(x64Operand &operand) +asmError x64Parser::Opcode101(x64Operand &operand) { - operand.values[19] = OpcodeCodings99_19; + operand.values[19] = OpcodeCodings101_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings100_19[] = { +Coding x64Parser::OpcodeCodings102_19[] = { { CODING_NAME("daa") Coding::stateFunc, 7 }, { CODING_NAME("daa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode100(x64Operand &operand) +asmError x64Parser::Opcode102(x64Operand &operand) { - operand.values[19] = OpcodeCodings100_19; + operand.values[19] = OpcodeCodings102_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings101_19[] = { +Coding x64Parser::OpcodeCodings103_19[] = { { CODING_NAME("das") Coding::stateFunc, 7 }, { CODING_NAME("das") (Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode101(x64Operand &operand) +asmError x64Parser::Opcode103(x64Operand &operand) { - operand.values[19] = OpcodeCodings101_19; + operand.values[19] = OpcodeCodings103_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings102_18[] = { +Coding x64Parser::OpcodeCodings104_18[] = { { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings102_19[] = { +Coding x64Parser::OpcodeCodings104_19[] = { { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode102(x64Operand &operand) +asmError x64Parser::Opcode104(x64Operand &operand) { - operand.values[18] = OpcodeCodings102_18; - operand.values[19] = OpcodeCodings102_19; + operand.values[18] = OpcodeCodings104_18; + operand.values[19] = OpcodeCodings104_19; asmError rv; { rv = Opcode6(operand); } return rv; } -Coding x64Parser::OpcodeCodings103_18[] = { +Coding x64Parser::OpcodeCodings105_18[] = { { CODING_NAME("div") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode103(x64Operand &operand) +asmError x64Parser::Opcode105(x64Operand &operand) { - operand.values[18] = OpcodeCodings103_18; + operand.values[18] = OpcodeCodings105_18; asmError rv; { rv = Opcode7(operand); } return rv; } -asmError x64Parser::Opcode104(x64Operand &operand) +asmError x64Parser::Opcode106(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6253, operand); + asmError rv = ParseOperands(tokenBranches6259, operand); return rv; } -asmError x64Parser::Opcode105(x64Operand &operand) +asmError x64Parser::Opcode107(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6259, operand); + asmError rv = ParseOperands(tokenBranches6265, operand); return rv; } -Coding x64Parser::OpcodeCodings106_19[] = { +Coding x64Parser::OpcodeCodings108_19[] = { { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode106(x64Operand &operand) +asmError x64Parser::Opcode108(x64Operand &operand) { - operand.values[19] = OpcodeCodings106_19; + operand.values[19] = OpcodeCodings108_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings107_19[] = { +Coding x64Parser::OpcodeCodings109_19[] = { { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode107(x64Operand &operand) +asmError x64Parser::Opcode109(x64Operand &operand) { - operand.values[19] = OpcodeCodings107_19; + operand.values[19] = OpcodeCodings109_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings108_18[] = { +Coding x64Parser::OpcodeCodings110_18[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings108_39[] = { +Coding x64Parser::OpcodeCodings110_39[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings108_36[] = { +Coding x64Parser::OpcodeCodings110_36[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode108(x64Operand &operand) +asmError x64Parser::Opcode110(x64Operand &operand) { - operand.values[18] = OpcodeCodings108_18; - operand.values[39] = OpcodeCodings108_39; - operand.values[36] = OpcodeCodings108_36; + operand.values[18] = OpcodeCodings110_18; + operand.values[39] = OpcodeCodings110_39; + operand.values[36] = OpcodeCodings110_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings109_18[] = { +Coding x64Parser::OpcodeCodings111_18[] = { { CODING_NAME("faddp") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings109_19[] = { +Coding x64Parser::OpcodeCodings111_19[] = { { CODING_NAME("faddp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode109(x64Operand &operand) +asmError x64Parser::Opcode111(x64Operand &operand) { - operand.values[18] = OpcodeCodings109_18; - operand.values[19] = OpcodeCodings109_19; + operand.values[18] = OpcodeCodings111_18; + operand.values[19] = OpcodeCodings111_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings110_18[] = { +Coding x64Parser::OpcodeCodings112_18[] = { { CODING_NAME("fbld") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings110_19[] = { +Coding x64Parser::OpcodeCodings112_19[] = { { CODING_NAME("fbld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode110(x64Operand &operand) +asmError x64Parser::Opcode112(x64Operand &operand) { - operand.values[18] = OpcodeCodings110_18; - operand.values[19] = OpcodeCodings110_19; + operand.values[18] = OpcodeCodings112_18; + operand.values[19] = OpcodeCodings112_19; asmError rv; { rv = Opcode11(operand); } return rv; } -Coding x64Parser::OpcodeCodings111_18[] = { +Coding x64Parser::OpcodeCodings113_18[] = { { CODING_NAME("fbstp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings111_19[] = { +Coding x64Parser::OpcodeCodings113_19[] = { { CODING_NAME("fbstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode111(x64Operand &operand) +asmError x64Parser::Opcode113(x64Operand &operand) { - operand.values[18] = OpcodeCodings111_18; - operand.values[19] = OpcodeCodings111_19; + operand.values[18] = OpcodeCodings113_18; + operand.values[19] = OpcodeCodings113_19; asmError rv; { rv = Opcode11(operand); } return rv; } -Coding x64Parser::OpcodeCodings112_19[] = { +Coding x64Parser::OpcodeCodings114_19[] = { { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode112(x64Operand &operand) +asmError x64Parser::Opcode114(x64Operand &operand) { - operand.values[19] = OpcodeCodings112_19; + operand.values[19] = OpcodeCodings114_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings113_19[] = { +Coding x64Parser::OpcodeCodings115_19[] = { { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode113(x64Operand &operand) +asmError x64Parser::Opcode115(x64Operand &operand) { - operand.values[19] = OpcodeCodings113_19; + operand.values[19] = OpcodeCodings115_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings114_19[] = { +Coding x64Parser::OpcodeCodings116_19[] = { { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode114(x64Operand &operand) +asmError x64Parser::Opcode116(x64Operand &operand) { - operand.values[19] = OpcodeCodings114_19; + operand.values[19] = OpcodeCodings116_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings115_18[] = { - { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings115_36[] = { - { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode115(x64Operand &operand) -{ - operand.values[18] = OpcodeCodings115_18; - operand.values[36] = OpcodeCodings115_36; - asmError rv = ParseOperands(tokenBranches6272, operand); - return rv; -} -Coding x64Parser::OpcodeCodings116_18[] = { - { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings116_36[] = { - { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode116(x64Operand &operand) -{ - operand.values[18] = OpcodeCodings116_18; - operand.values[36] = OpcodeCodings116_36; - asmError rv = ParseOperands(tokenBranches6276, operand); - return rv; -} Coding x64Parser::OpcodeCodings117_18[] = { - { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings117_36[] = { - { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode117(x64Operand &operand) { operand.values[18] = OpcodeCodings117_18; operand.values[36] = OpcodeCodings117_36; - asmError rv = ParseOperands(tokenBranches6280, operand); + asmError rv = ParseOperands(tokenBranches6278, operand); return rv; } Coding x64Parser::OpcodeCodings118_18[] = { - { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings118_36[] = { - { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode118(x64Operand &operand) { operand.values[18] = OpcodeCodings118_18; operand.values[36] = OpcodeCodings118_36; - asmError rv = ParseOperands(tokenBranches6284, operand); + asmError rv = ParseOperands(tokenBranches6282, operand); return rv; } Coding x64Parser::OpcodeCodings119_18[] = { - { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings119_36[] = { - { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode119(x64Operand &operand) { operand.values[18] = OpcodeCodings119_18; operand.values[36] = OpcodeCodings119_36; - asmError rv = ParseOperands(tokenBranches6288, operand); + asmError rv = ParseOperands(tokenBranches6286, operand); return rv; } Coding x64Parser::OpcodeCodings120_18[] = { - { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings120_36[] = { - { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode120(x64Operand &operand) { operand.values[18] = OpcodeCodings120_18; operand.values[36] = OpcodeCodings120_36; - asmError rv = ParseOperands(tokenBranches6292, operand); + asmError rv = ParseOperands(tokenBranches6290, operand); return rv; } Coding x64Parser::OpcodeCodings121_18[] = { - { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings121_36[] = { - { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode121(x64Operand &operand) { operand.values[18] = OpcodeCodings121_18; operand.values[36] = OpcodeCodings121_36; - asmError rv = ParseOperands(tokenBranches6296, operand); + asmError rv = ParseOperands(tokenBranches6294, operand); return rv; } Coding x64Parser::OpcodeCodings122_18[] = { - { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings122_36[] = { - { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode122(x64Operand &operand) { operand.values[18] = OpcodeCodings122_18; operand.values[36] = OpcodeCodings122_36; - asmError rv = ParseOperands(tokenBranches6300, operand); + asmError rv = ParseOperands(tokenBranches6298, operand); return rv; } Coding x64Parser::OpcodeCodings123_18[] = { - { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings123_36[] = { - { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode123(x64Operand &operand) { operand.values[18] = OpcodeCodings123_18; operand.values[36] = OpcodeCodings123_36; - asmError rv = ParseOperands(tokenBranches6304, operand); + asmError rv = ParseOperands(tokenBranches6302, operand); return rv; } Coding x64Parser::OpcodeCodings124_18[] = { - { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings124_36[] = { - { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode124(x64Operand &operand) { operand.values[18] = OpcodeCodings124_18; operand.values[36] = OpcodeCodings124_36; - asmError rv = ParseOperands(tokenBranches6313, operand); + asmError rv = ParseOperands(tokenBranches6306, operand); return rv; } Coding x64Parser::OpcodeCodings125_18[] = { - { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings125_36[] = { - { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode125(x64Operand &operand) { operand.values[18] = OpcodeCodings125_18; operand.values[36] = OpcodeCodings125_36; - asmError rv = ParseOperands(tokenBranches6317, operand); + asmError rv = ParseOperands(tokenBranches6310, operand); return rv; } Coding x64Parser::OpcodeCodings126_18[] = { - { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings126_36[] = { - { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode126(x64Operand &operand) { operand.values[18] = OpcodeCodings126_18; operand.values[36] = OpcodeCodings126_36; - asmError rv = ParseOperands(tokenBranches6321, operand); + asmError rv = ParseOperands(tokenBranches6319, operand); + return rv; +} +Coding x64Parser::OpcodeCodings127_18[] = { + { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings127_36[] = { + { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode127(x64Operand &operand) +{ + operand.values[18] = OpcodeCodings127_18; + operand.values[36] = OpcodeCodings127_36; + asmError rv = ParseOperands(tokenBranches6323, operand); + return rv; +} +Coding x64Parser::OpcodeCodings128_18[] = { + { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings128_36[] = { + { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode128(x64Operand &operand) +{ + operand.values[18] = OpcodeCodings128_18; + operand.values[36] = OpcodeCodings128_36; + asmError rv = ParseOperands(tokenBranches6327, operand); return rv; } -Coding x64Parser::OpcodeCodings127_19[] = { +Coding x64Parser::OpcodeCodings129_19[] = { { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode127(x64Operand &operand) +asmError x64Parser::Opcode129(x64Operand &operand) { - operand.values[19] = OpcodeCodings127_19; + operand.values[19] = OpcodeCodings129_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings128_19[] = { +Coding x64Parser::OpcodeCodings130_19[] = { { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode128(x64Operand &operand) +asmError x64Parser::Opcode130(x64Operand &operand) { - operand.values[19] = OpcodeCodings128_19; + operand.values[19] = OpcodeCodings130_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings129_19[] = { +Coding x64Parser::OpcodeCodings131_19[] = { { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode129(x64Operand &operand) +asmError x64Parser::Opcode131(x64Operand &operand) { - operand.values[19] = OpcodeCodings129_19; + operand.values[19] = OpcodeCodings131_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings130_19[] = { +Coding x64Parser::OpcodeCodings132_19[] = { { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode130(x64Operand &operand) +asmError x64Parser::Opcode132(x64Operand &operand) { - operand.values[19] = OpcodeCodings130_19; + operand.values[19] = OpcodeCodings132_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings131_18[] = { +Coding x64Parser::OpcodeCodings133_18[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings131_39[] = { +Coding x64Parser::OpcodeCodings133_39[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings131_36[] = { +Coding x64Parser::OpcodeCodings133_36[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode131(x64Operand &operand) +asmError x64Parser::Opcode133(x64Operand &operand) { - operand.values[18] = OpcodeCodings131_18; - operand.values[39] = OpcodeCodings131_39; - operand.values[36] = OpcodeCodings131_36; + operand.values[18] = OpcodeCodings133_18; + operand.values[39] = OpcodeCodings133_39; + operand.values[36] = OpcodeCodings133_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings132_18[] = { +Coding x64Parser::OpcodeCodings134_18[] = { { CODING_NAME("fdivp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings132_19[] = { +Coding x64Parser::OpcodeCodings134_19[] = { { CODING_NAME("fdivp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode132(x64Operand &operand) +asmError x64Parser::Opcode134(x64Operand &operand) { - operand.values[18] = OpcodeCodings132_18; - operand.values[19] = OpcodeCodings132_19; + operand.values[18] = OpcodeCodings134_18; + operand.values[19] = OpcodeCodings134_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings133_18[] = { +Coding x64Parser::OpcodeCodings135_18[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings133_39[] = { +Coding x64Parser::OpcodeCodings135_39[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings133_36[] = { +Coding x64Parser::OpcodeCodings135_36[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode133(x64Operand &operand) +asmError x64Parser::Opcode135(x64Operand &operand) { - operand.values[18] = OpcodeCodings133_18; - operand.values[39] = OpcodeCodings133_39; - operand.values[36] = OpcodeCodings133_36; + operand.values[18] = OpcodeCodings135_18; + operand.values[39] = OpcodeCodings135_39; + operand.values[36] = OpcodeCodings135_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings134_18[] = { +Coding x64Parser::OpcodeCodings136_18[] = { { CODING_NAME("fdivrp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings134_19[] = { +Coding x64Parser::OpcodeCodings136_19[] = { { CODING_NAME("fdivrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode134(x64Operand &operand) +asmError x64Parser::Opcode136(x64Operand &operand) { - operand.values[18] = OpcodeCodings134_18; - operand.values[19] = OpcodeCodings134_19; + operand.values[18] = OpcodeCodings136_18; + operand.values[19] = OpcodeCodings136_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings135_19[] = { +Coding x64Parser::OpcodeCodings137_19[] = { { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode135(x64Operand &operand) +asmError x64Parser::Opcode137(x64Operand &operand) { - operand.values[19] = OpcodeCodings135_19; + operand.values[19] = OpcodeCodings137_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode136(x64Operand &operand) +asmError x64Parser::Opcode138(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6336, operand); + asmError rv = ParseOperands(tokenBranches6342, operand); return rv; } -asmError x64Parser::Opcode137(x64Operand &operand) +asmError x64Parser::Opcode139(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6338, operand); + asmError rv = ParseOperands(tokenBranches6344, operand); return rv; } -Coding x64Parser::OpcodeCodings138_18[] = { +Coding x64Parser::OpcodeCodings140_18[] = { { CODING_NAME("fiadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings138_36[] = { +Coding x64Parser::OpcodeCodings140_36[] = { { CODING_NAME("fiadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode138(x64Operand &operand) +asmError x64Parser::Opcode140(x64Operand &operand) { - operand.values[18] = OpcodeCodings138_18; - operand.values[36] = OpcodeCodings138_36; + operand.values[18] = OpcodeCodings140_18; + operand.values[36] = OpcodeCodings140_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings139_18[] = { +Coding x64Parser::OpcodeCodings141_18[] = { { CODING_NAME("ficom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings139_36[] = { +Coding x64Parser::OpcodeCodings141_36[] = { { CODING_NAME("ficom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode139(x64Operand &operand) +asmError x64Parser::Opcode141(x64Operand &operand) { - operand.values[18] = OpcodeCodings139_18; - operand.values[36] = OpcodeCodings139_36; + operand.values[18] = OpcodeCodings141_18; + operand.values[36] = OpcodeCodings141_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings140_18[] = { +Coding x64Parser::OpcodeCodings142_18[] = { { CODING_NAME("ficomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings140_36[] = { +Coding x64Parser::OpcodeCodings142_36[] = { { CODING_NAME("ficomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode140(x64Operand &operand) +asmError x64Parser::Opcode142(x64Operand &operand) { - operand.values[18] = OpcodeCodings140_18; - operand.values[36] = OpcodeCodings140_36; + operand.values[18] = OpcodeCodings142_18; + operand.values[36] = OpcodeCodings142_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings141_18[] = { +Coding x64Parser::OpcodeCodings143_18[] = { { CODING_NAME("fidiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings141_36[] = { +Coding x64Parser::OpcodeCodings143_36[] = { { CODING_NAME("fidiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode141(x64Operand &operand) +asmError x64Parser::Opcode143(x64Operand &operand) { - operand.values[18] = OpcodeCodings141_18; - operand.values[36] = OpcodeCodings141_36; + operand.values[18] = OpcodeCodings143_18; + operand.values[36] = OpcodeCodings143_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings142_18[] = { +Coding x64Parser::OpcodeCodings144_18[] = { { CODING_NAME("fidivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings142_36[] = { +Coding x64Parser::OpcodeCodings144_36[] = { { CODING_NAME("fidivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode142(x64Operand &operand) +asmError x64Parser::Opcode144(x64Operand &operand) { - operand.values[18] = OpcodeCodings142_18; - operand.values[36] = OpcodeCodings142_36; + operand.values[18] = OpcodeCodings144_18; + operand.values[36] = OpcodeCodings144_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings143_18[] = { +Coding x64Parser::OpcodeCodings145_18[] = { { CODING_NAME("fild") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings143_36[] = { +Coding x64Parser::OpcodeCodings145_36[] = { { CODING_NAME("fild") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode143(x64Operand &operand) +asmError x64Parser::Opcode145(x64Operand &operand) { - operand.values[18] = OpcodeCodings143_18; - operand.values[36] = OpcodeCodings143_36; - asmError rv = ParseOperands(tokenBranches6345, operand); + operand.values[18] = OpcodeCodings145_18; + operand.values[36] = OpcodeCodings145_36; + asmError rv = ParseOperands(tokenBranches6351, operand); return rv; } -Coding x64Parser::OpcodeCodings144_18[] = { +Coding x64Parser::OpcodeCodings146_18[] = { { CODING_NAME("fimul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings144_36[] = { +Coding x64Parser::OpcodeCodings146_36[] = { { CODING_NAME("fimul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode144(x64Operand &operand) +asmError x64Parser::Opcode146(x64Operand &operand) { - operand.values[18] = OpcodeCodings144_18; - operand.values[36] = OpcodeCodings144_36; + operand.values[18] = OpcodeCodings146_18; + operand.values[36] = OpcodeCodings146_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings145_19[] = { +Coding x64Parser::OpcodeCodings147_19[] = { { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode145(x64Operand &operand) +asmError x64Parser::Opcode147(x64Operand &operand) { - operand.values[19] = OpcodeCodings145_19; + operand.values[19] = OpcodeCodings147_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings146_19[] = { +Coding x64Parser::OpcodeCodings148_19[] = { { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode146(x64Operand &operand) +asmError x64Parser::Opcode148(x64Operand &operand) { - operand.values[19] = OpcodeCodings146_19; + operand.values[19] = OpcodeCodings148_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings147_19[] = { +Coding x64Parser::OpcodeCodings149_19[] = { { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode147(x64Operand &operand) +asmError x64Parser::Opcode149(x64Operand &operand) { - operand.values[19] = OpcodeCodings147_19; + operand.values[19] = OpcodeCodings149_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings148_18[] = { +Coding x64Parser::OpcodeCodings150_18[] = { { CODING_NAME("fist") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings148_36[] = { +Coding x64Parser::OpcodeCodings150_36[] = { { CODING_NAME("fist") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode148(x64Operand &operand) +asmError x64Parser::Opcode150(x64Operand &operand) { - operand.values[18] = OpcodeCodings148_18; - operand.values[36] = OpcodeCodings148_36; + operand.values[18] = OpcodeCodings150_18; + operand.values[36] = OpcodeCodings150_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings149_18[] = { +Coding x64Parser::OpcodeCodings151_18[] = { { CODING_NAME("fistp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings149_36[] = { +Coding x64Parser::OpcodeCodings151_36[] = { { CODING_NAME("fistp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode149(x64Operand &operand) +asmError x64Parser::Opcode151(x64Operand &operand) { - operand.values[18] = OpcodeCodings149_18; - operand.values[36] = OpcodeCodings149_36; - asmError rv = ParseOperands(tokenBranches6357, operand); + operand.values[18] = OpcodeCodings151_18; + operand.values[36] = OpcodeCodings151_36; + asmError rv = ParseOperands(tokenBranches6363, operand); return rv; } -Coding x64Parser::OpcodeCodings150_18[] = { +Coding x64Parser::OpcodeCodings152_18[] = { { CODING_NAME("fisub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings150_36[] = { +Coding x64Parser::OpcodeCodings152_36[] = { { CODING_NAME("fisub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode150(x64Operand &operand) +asmError x64Parser::Opcode152(x64Operand &operand) { - operand.values[18] = OpcodeCodings150_18; - operand.values[36] = OpcodeCodings150_36; + operand.values[18] = OpcodeCodings152_18; + operand.values[36] = OpcodeCodings152_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings151_18[] = { +Coding x64Parser::OpcodeCodings153_18[] = { { CODING_NAME("fisubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings151_36[] = { +Coding x64Parser::OpcodeCodings153_36[] = { { CODING_NAME("fisubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode151(x64Operand &operand) +asmError x64Parser::Opcode153(x64Operand &operand) { - operand.values[18] = OpcodeCodings151_18; - operand.values[36] = OpcodeCodings151_36; + operand.values[18] = OpcodeCodings153_18; + operand.values[36] = OpcodeCodings153_36; asmError rv; { rv = Opcode10(operand); } return rv; } -asmError x64Parser::Opcode152(x64Operand &operand) +asmError x64Parser::Opcode154(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6364, operand); + asmError rv = ParseOperands(tokenBranches6370, operand); return rv; } -Coding x64Parser::OpcodeCodings153_19[] = { +Coding x64Parser::OpcodeCodings155_19[] = { { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode153(x64Operand &operand) +asmError x64Parser::Opcode155(x64Operand &operand) { - operand.values[19] = OpcodeCodings153_19; + operand.values[19] = OpcodeCodings155_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode154(x64Operand &operand) +asmError x64Parser::Opcode156(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6373, operand); + asmError rv = ParseOperands(tokenBranches6379, operand); return rv; } -asmError x64Parser::Opcode155(x64Operand &operand) +asmError x64Parser::Opcode157(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6376, operand); + asmError rv = ParseOperands(tokenBranches6382, operand); return rv; } -Coding x64Parser::OpcodeCodings156_19[] = { +Coding x64Parser::OpcodeCodings158_19[] = { { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode156(x64Operand &operand) +asmError x64Parser::Opcode158(x64Operand &operand) { - operand.values[19] = OpcodeCodings156_19; + operand.values[19] = OpcodeCodings158_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings157_19[] = { +Coding x64Parser::OpcodeCodings159_19[] = { { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode157(x64Operand &operand) +asmError x64Parser::Opcode159(x64Operand &operand) { - operand.values[19] = OpcodeCodings157_19; + operand.values[19] = OpcodeCodings159_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings158_19[] = { +Coding x64Parser::OpcodeCodings160_19[] = { { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode158(x64Operand &operand) +asmError x64Parser::Opcode160(x64Operand &operand) { - operand.values[19] = OpcodeCodings158_19; + operand.values[19] = OpcodeCodings160_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings159_19[] = { +Coding x64Parser::OpcodeCodings161_19[] = { { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode159(x64Operand &operand) +asmError x64Parser::Opcode161(x64Operand &operand) { - operand.values[19] = OpcodeCodings159_19; + operand.values[19] = OpcodeCodings161_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings160_19[] = { +Coding x64Parser::OpcodeCodings162_19[] = { { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode160(x64Operand &operand) +asmError x64Parser::Opcode162(x64Operand &operand) { - operand.values[19] = OpcodeCodings160_19; + operand.values[19] = OpcodeCodings162_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings161_19[] = { +Coding x64Parser::OpcodeCodings163_19[] = { { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode161(x64Operand &operand) +asmError x64Parser::Opcode163(x64Operand &operand) { - operand.values[19] = OpcodeCodings161_19; + operand.values[19] = OpcodeCodings163_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings162_18[] = { +Coding x64Parser::OpcodeCodings164_18[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings162_39[] = { +Coding x64Parser::OpcodeCodings164_39[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings162_36[] = { +Coding x64Parser::OpcodeCodings164_36[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode162(x64Operand &operand) +asmError x64Parser::Opcode164(x64Operand &operand) { - operand.values[18] = OpcodeCodings162_18; - operand.values[39] = OpcodeCodings162_39; - operand.values[36] = OpcodeCodings162_36; + operand.values[18] = OpcodeCodings164_18; + operand.values[39] = OpcodeCodings164_39; + operand.values[36] = OpcodeCodings164_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings163_18[] = { +Coding x64Parser::OpcodeCodings165_18[] = { { CODING_NAME("fmulp") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings163_19[] = { +Coding x64Parser::OpcodeCodings165_19[] = { { CODING_NAME("fmulp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode163(x64Operand &operand) +asmError x64Parser::Opcode165(x64Operand &operand) { - operand.values[18] = OpcodeCodings163_18; - operand.values[19] = OpcodeCodings163_19; + operand.values[18] = OpcodeCodings165_18; + operand.values[19] = OpcodeCodings165_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings164_19[] = { +Coding x64Parser::OpcodeCodings166_19[] = { { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode164(x64Operand &operand) +asmError x64Parser::Opcode166(x64Operand &operand) { - operand.values[19] = OpcodeCodings164_19; + operand.values[19] = OpcodeCodings166_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode165(x64Operand &operand) +asmError x64Parser::Opcode167(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6387, operand); + asmError rv = ParseOperands(tokenBranches6393, operand); return rv; } -Coding x64Parser::OpcodeCodings166_19[] = { +Coding x64Parser::OpcodeCodings168_19[] = { { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode166(x64Operand &operand) +asmError x64Parser::Opcode168(x64Operand &operand) { - operand.values[19] = OpcodeCodings166_19; + operand.values[19] = OpcodeCodings168_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings167_19[] = { +Coding x64Parser::OpcodeCodings169_19[] = { { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode167(x64Operand &operand) +asmError x64Parser::Opcode169(x64Operand &operand) { - operand.values[19] = OpcodeCodings167_19; + operand.values[19] = OpcodeCodings169_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings168_19[] = { +Coding x64Parser::OpcodeCodings170_19[] = { { CODING_NAME("fprem1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fprem1") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode168(x64Operand &operand) +asmError x64Parser::Opcode170(x64Operand &operand) { - operand.values[19] = OpcodeCodings168_19; + operand.values[19] = OpcodeCodings170_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings169_19[] = { +Coding x64Parser::OpcodeCodings171_19[] = { { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode169(x64Operand &operand) +asmError x64Parser::Opcode171(x64Operand &operand) { - operand.values[19] = OpcodeCodings169_19; + operand.values[19] = OpcodeCodings171_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings170_19[] = { +Coding x64Parser::OpcodeCodings172_19[] = { { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode170(x64Operand &operand) +asmError x64Parser::Opcode172(x64Operand &operand) { - operand.values[19] = OpcodeCodings170_19; + operand.values[19] = OpcodeCodings172_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode171(x64Operand &operand) +asmError x64Parser::Opcode173(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6394, operand); + asmError rv = ParseOperands(tokenBranches6400, operand); return rv; } -asmError x64Parser::Opcode172(x64Operand &operand) +asmError x64Parser::Opcode174(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6396, operand); + asmError rv = ParseOperands(tokenBranches6402, operand); return rv; } -Coding x64Parser::OpcodeCodings173_19[] = { +Coding x64Parser::OpcodeCodings175_19[] = { { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode173(x64Operand &operand) +asmError x64Parser::Opcode175(x64Operand &operand) { - operand.values[19] = OpcodeCodings173_19; + operand.values[19] = OpcodeCodings175_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings174_19[] = { +Coding x64Parser::OpcodeCodings176_19[] = { { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode174(x64Operand &operand) +asmError x64Parser::Opcode176(x64Operand &operand) { - operand.values[19] = OpcodeCodings174_19; + operand.values[19] = OpcodeCodings176_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings175_19[] = { +Coding x64Parser::OpcodeCodings177_19[] = { { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode175(x64Operand &operand) +asmError x64Parser::Opcode177(x64Operand &operand) { - operand.values[19] = OpcodeCodings175_19; + operand.values[19] = OpcodeCodings177_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings176_19[] = { +Coding x64Parser::OpcodeCodings178_19[] = { { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode176(x64Operand &operand) +asmError x64Parser::Opcode178(x64Operand &operand) { - operand.values[19] = OpcodeCodings176_19; + operand.values[19] = OpcodeCodings178_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings177_19[] = { +Coding x64Parser::OpcodeCodings179_19[] = { { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode177(x64Operand &operand) +asmError x64Parser::Opcode179(x64Operand &operand) { - operand.values[19] = OpcodeCodings177_19; + operand.values[19] = OpcodeCodings179_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode178(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6403, operand); - return rv; -} -asmError x64Parser::Opcode179(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6409, operand); - return rv; -} asmError x64Parser::Opcode180(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6412, operand); + asmError rv = ParseOperands(tokenBranches6409, operand); return rv; } asmError x64Parser::Opcode181(x64Operand &operand) @@ -40092,651 +40161,635 @@ asmError x64Parser::Opcode181(x64Operand &operand) } asmError x64Parser::Opcode182(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6417, operand); + asmError rv = ParseOperands(tokenBranches6418, operand); return rv; } asmError x64Parser::Opcode183(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6419, operand); + asmError rv = ParseOperands(tokenBranches6421, operand); return rv; } asmError x64Parser::Opcode184(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6427, operand); + asmError rv = ParseOperands(tokenBranches6423, operand); return rv; } asmError x64Parser::Opcode185(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6431, operand); + asmError rv = ParseOperands(tokenBranches6425, operand); + return rv; +} +asmError x64Parser::Opcode186(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6433, operand); return rv; } -Coding x64Parser::OpcodeCodings186_18[] = { +asmError x64Parser::Opcode187(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6437, operand); + return rv; +} +Coding x64Parser::OpcodeCodings188_18[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings186_39[] = { +Coding x64Parser::OpcodeCodings188_39[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings186_36[] = { +Coding x64Parser::OpcodeCodings188_36[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode186(x64Operand &operand) +asmError x64Parser::Opcode188(x64Operand &operand) { - operand.values[18] = OpcodeCodings186_18; - operand.values[39] = OpcodeCodings186_39; - operand.values[36] = OpcodeCodings186_36; + operand.values[18] = OpcodeCodings188_18; + operand.values[39] = OpcodeCodings188_39; + operand.values[36] = OpcodeCodings188_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings187_18[] = { +Coding x64Parser::OpcodeCodings189_18[] = { { CODING_NAME("fsubp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings187_19[] = { +Coding x64Parser::OpcodeCodings189_19[] = { { CODING_NAME("fsubp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode187(x64Operand &operand) +asmError x64Parser::Opcode189(x64Operand &operand) { - operand.values[18] = OpcodeCodings187_18; - operand.values[19] = OpcodeCodings187_19; + operand.values[18] = OpcodeCodings189_18; + operand.values[19] = OpcodeCodings189_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings188_18[] = { +Coding x64Parser::OpcodeCodings190_18[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings188_39[] = { +Coding x64Parser::OpcodeCodings190_39[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings188_36[] = { +Coding x64Parser::OpcodeCodings190_36[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode188(x64Operand &operand) +asmError x64Parser::Opcode190(x64Operand &operand) { - operand.values[18] = OpcodeCodings188_18; - operand.values[39] = OpcodeCodings188_39; - operand.values[36] = OpcodeCodings188_36; + operand.values[18] = OpcodeCodings190_18; + operand.values[39] = OpcodeCodings190_39; + operand.values[36] = OpcodeCodings190_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings189_18[] = { +Coding x64Parser::OpcodeCodings191_18[] = { { CODING_NAME("fsubrp") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings189_19[] = { +Coding x64Parser::OpcodeCodings191_19[] = { { CODING_NAME("fsubrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode189(x64Operand &operand) +asmError x64Parser::Opcode191(x64Operand &operand) { - operand.values[18] = OpcodeCodings189_18; - operand.values[19] = OpcodeCodings189_19; + operand.values[18] = OpcodeCodings191_18; + operand.values[19] = OpcodeCodings191_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings190_19[] = { +Coding x64Parser::OpcodeCodings192_19[] = { { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode190(x64Operand &operand) +asmError x64Parser::Opcode192(x64Operand &operand) { - operand.values[19] = OpcodeCodings190_19; + operand.values[19] = OpcodeCodings192_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings191_18[] = { +Coding x64Parser::OpcodeCodings193_18[] = { { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings191_19[] = { +Coding x64Parser::OpcodeCodings193_19[] = { { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode191(x64Operand &operand) +asmError x64Parser::Opcode193(x64Operand &operand) { - operand.values[18] = OpcodeCodings191_18; - operand.values[19] = OpcodeCodings191_19; + operand.values[18] = OpcodeCodings193_18; + operand.values[19] = OpcodeCodings193_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings192_18[] = { +Coding x64Parser::OpcodeCodings194_18[] = { { CODING_NAME("fucomi") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings192_36[] = { +Coding x64Parser::OpcodeCodings194_36[] = { { CODING_NAME("fucomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode192(x64Operand &operand) +asmError x64Parser::Opcode194(x64Operand &operand) { - operand.values[18] = OpcodeCodings192_18; - operand.values[36] = OpcodeCodings192_36; - asmError rv = ParseOperands(tokenBranches6441, operand); + operand.values[18] = OpcodeCodings194_18; + operand.values[36] = OpcodeCodings194_36; + asmError rv = ParseOperands(tokenBranches6447, operand); return rv; } -Coding x64Parser::OpcodeCodings193_18[] = { +Coding x64Parser::OpcodeCodings195_18[] = { { CODING_NAME("fucomip") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings193_36[] = { +Coding x64Parser::OpcodeCodings195_36[] = { { CODING_NAME("fucomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode193(x64Operand &operand) +asmError x64Parser::Opcode195(x64Operand &operand) { - operand.values[18] = OpcodeCodings193_18; - operand.values[36] = OpcodeCodings193_36; - asmError rv = ParseOperands(tokenBranches6445, operand); + operand.values[18] = OpcodeCodings195_18; + operand.values[36] = OpcodeCodings195_36; + asmError rv = ParseOperands(tokenBranches6451, operand); return rv; } -Coding x64Parser::OpcodeCodings194_18[] = { +Coding x64Parser::OpcodeCodings196_18[] = { { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings194_19[] = { +Coding x64Parser::OpcodeCodings196_19[] = { { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode194(x64Operand &operand) +asmError x64Parser::Opcode196(x64Operand &operand) { - operand.values[18] = OpcodeCodings194_18; - operand.values[19] = OpcodeCodings194_19; + operand.values[18] = OpcodeCodings196_18; + operand.values[19] = OpcodeCodings196_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings195_19[] = { +Coding x64Parser::OpcodeCodings197_19[] = { { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode195(x64Operand &operand) +asmError x64Parser::Opcode197(x64Operand &operand) { - operand.values[19] = OpcodeCodings195_19; + operand.values[19] = OpcodeCodings197_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings196_19[] = { +Coding x64Parser::OpcodeCodings198_19[] = { { CODING_NAME("fwait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode196(x64Operand &operand) +asmError x64Parser::Opcode198(x64Operand &operand) { - operand.values[19] = OpcodeCodings196_19; + operand.values[19] = OpcodeCodings198_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings197_19[] = { +Coding x64Parser::OpcodeCodings199_19[] = { { CODING_NAME("fxam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fxam") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode197(x64Operand &operand) +asmError x64Parser::Opcode199(x64Operand &operand) { - operand.values[19] = OpcodeCodings197_19; + operand.values[19] = OpcodeCodings199_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings198_18[] = { +Coding x64Parser::OpcodeCodings200_18[] = { { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings198_19[] = { +Coding x64Parser::OpcodeCodings200_19[] = { { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode198(x64Operand &operand) +asmError x64Parser::Opcode200(x64Operand &operand) { - operand.values[18] = OpcodeCodings198_18; - operand.values[19] = OpcodeCodings198_19; + operand.values[18] = OpcodeCodings200_18; + operand.values[19] = OpcodeCodings200_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings199_18[] = { +Coding x64Parser::OpcodeCodings201_18[] = { { CODING_NAME("fxch4") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings199_36[] = { +Coding x64Parser::OpcodeCodings201_36[] = { { CODING_NAME("fxch4") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode199(x64Operand &operand) +asmError x64Parser::Opcode201(x64Operand &operand) { - operand.values[18] = OpcodeCodings199_18; - operand.values[36] = OpcodeCodings199_36; - asmError rv = ParseOperands(tokenBranches6454, operand); + operand.values[18] = OpcodeCodings201_18; + operand.values[36] = OpcodeCodings201_36; + asmError rv = ParseOperands(tokenBranches6460, operand); return rv; } -Coding x64Parser::OpcodeCodings200_18[] = { +Coding x64Parser::OpcodeCodings202_18[] = { { CODING_NAME("fxch7") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings200_36[] = { +Coding x64Parser::OpcodeCodings202_36[] = { { CODING_NAME("fxch7") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode200(x64Operand &operand) +asmError x64Parser::Opcode202(x64Operand &operand) { - operand.values[18] = OpcodeCodings200_18; - operand.values[36] = OpcodeCodings200_36; - asmError rv = ParseOperands(tokenBranches6458, operand); + operand.values[18] = OpcodeCodings202_18; + operand.values[36] = OpcodeCodings202_36; + asmError rv = ParseOperands(tokenBranches6464, operand); return rv; } -asmError x64Parser::Opcode201(x64Operand &operand) +asmError x64Parser::Opcode203(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6462, operand); + asmError rv = ParseOperands(tokenBranches6468, operand); return rv; } -asmError x64Parser::Opcode202(x64Operand &operand) +asmError x64Parser::Opcode204(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6464, operand); + asmError rv = ParseOperands(tokenBranches6470, operand); return rv; } -Coding x64Parser::OpcodeCodings203_19[] = { +Coding x64Parser::OpcodeCodings205_19[] = { { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode203(x64Operand &operand) +asmError x64Parser::Opcode205(x64Operand &operand) { - operand.values[19] = OpcodeCodings203_19; + operand.values[19] = OpcodeCodings205_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings204_19[] = { +Coding x64Parser::OpcodeCodings206_19[] = { { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode204(x64Operand &operand) +asmError x64Parser::Opcode206(x64Operand &operand) { - operand.values[19] = OpcodeCodings204_19; + operand.values[19] = OpcodeCodings206_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings205_19[] = { +Coding x64Parser::OpcodeCodings207_19[] = { { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode205(x64Operand &operand) +asmError x64Parser::Opcode207(x64Operand &operand) { - operand.values[19] = OpcodeCodings205_19; + operand.values[19] = OpcodeCodings207_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings206_19[] = { +Coding x64Parser::OpcodeCodings208_19[] = { { CODING_NAME("hlt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode206(x64Operand &operand) +asmError x64Parser::Opcode208(x64Operand &operand) { - operand.values[19] = OpcodeCodings206_19; + operand.values[19] = OpcodeCodings208_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings207_19[] = { +Coding x64Parser::OpcodeCodings209_19[] = { { CODING_NAME("icebp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode207(x64Operand &operand) +asmError x64Parser::Opcode209(x64Operand &operand) { - operand.values[19] = OpcodeCodings207_19; + operand.values[19] = OpcodeCodings209_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings208_18[] = { +Coding x64Parser::OpcodeCodings210_18[] = { { CODING_NAME("idiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode208(x64Operand &operand) +asmError x64Parser::Opcode210(x64Operand &operand) { - operand.values[18] = OpcodeCodings208_18; + operand.values[18] = OpcodeCodings210_18; asmError rv; { rv = Opcode7(operand); } return rv; } -asmError x64Parser::Opcode209(x64Operand &operand) +asmError x64Parser::Opcode211(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6472, operand); + asmError rv = ParseOperands(tokenBranches6478, operand); return rv; } -asmError x64Parser::Opcode210(x64Operand &operand) +asmError x64Parser::Opcode212(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6556, operand); + asmError rv = ParseOperands(tokenBranches6562, operand); return rv; } -asmError x64Parser::Opcode211(x64Operand &operand) +asmError x64Parser::Opcode213(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6585, operand); + asmError rv = ParseOperands(tokenBranches6591, operand); return rv; } -Coding x64Parser::OpcodeCodings212_19[] = { +Coding x64Parser::OpcodeCodings214_19[] = { { CODING_NAME("insb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode212(x64Operand &operand) +asmError x64Parser::Opcode214(x64Operand &operand) { - operand.values[19] = OpcodeCodings212_19; + operand.values[19] = OpcodeCodings214_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings213_19[] = { +Coding x64Parser::OpcodeCodings215_19[] = { { CODING_NAME("insw") Coding::stateFunc, 4 }, { CODING_NAME("insw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode213(x64Operand &operand) +asmError x64Parser::Opcode215(x64Operand &operand) { - operand.values[19] = OpcodeCodings213_19; + operand.values[19] = OpcodeCodings215_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings214_19[] = { +Coding x64Parser::OpcodeCodings216_19[] = { { CODING_NAME("insd") Coding::stateFunc, 5 }, { CODING_NAME("insd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode214(x64Operand &operand) +asmError x64Parser::Opcode216(x64Operand &operand) { - operand.values[19] = OpcodeCodings214_19; + operand.values[19] = OpcodeCodings216_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings215_18[] = { +Coding x64Parser::OpcodeCodings217_18[] = { { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings215_19[] = { +Coding x64Parser::OpcodeCodings217_19[] = { { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode215(x64Operand &operand) +asmError x64Parser::Opcode217(x64Operand &operand) { - operand.values[18] = OpcodeCodings215_18; - operand.values[19] = OpcodeCodings215_19; + operand.values[18] = OpcodeCodings217_18; + operand.values[19] = OpcodeCodings217_19; asmError rv; { rv = Opcode6(operand); } return rv; } -asmError x64Parser::Opcode216(x64Operand &operand) +asmError x64Parser::Opcode218(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6728, operand); + asmError rv = ParseOperands(tokenBranches6734, operand); return rv; } -Coding x64Parser::OpcodeCodings217_19[] = { +Coding x64Parser::OpcodeCodings219_19[] = { { CODING_NAME("int1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode217(x64Operand &operand) +asmError x64Parser::Opcode219(x64Operand &operand) { - operand.values[19] = OpcodeCodings217_19; + operand.values[19] = OpcodeCodings219_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings218_19[] = { +Coding x64Parser::OpcodeCodings220_19[] = { { CODING_NAME("int3") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode218(x64Operand &operand) +asmError x64Parser::Opcode220(x64Operand &operand) { - operand.values[19] = OpcodeCodings218_19; + operand.values[19] = OpcodeCodings220_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings219_19[] = { +Coding x64Parser::OpcodeCodings221_19[] = { { CODING_NAME("into") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode219(x64Operand &operand) +asmError x64Parser::Opcode221(x64Operand &operand) { - operand.values[19] = OpcodeCodings219_19; + operand.values[19] = OpcodeCodings221_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings220_19[] = { +Coding x64Parser::OpcodeCodings222_19[] = { { CODING_NAME("invd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode220(x64Operand &operand) +asmError x64Parser::Opcode222(x64Operand &operand) { - operand.values[19] = OpcodeCodings220_19; + operand.values[19] = OpcodeCodings222_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode221(x64Operand &operand) +asmError x64Parser::Opcode223(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6735, operand); + asmError rv = ParseOperands(tokenBranches6741, operand); return rv; } -Coding x64Parser::OpcodeCodings222_19[] = { +Coding x64Parser::OpcodeCodings224_19[] = { { CODING_NAME("iret") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode222(x64Operand &operand) +asmError x64Parser::Opcode224(x64Operand &operand) { - operand.values[19] = OpcodeCodings222_19; + operand.values[19] = OpcodeCodings224_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings223_19[] = { +Coding x64Parser::OpcodeCodings225_19[] = { { CODING_NAME("iretw") Coding::stateFunc, 4 }, { CODING_NAME("iretw") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode223(x64Operand &operand) +asmError x64Parser::Opcode225(x64Operand &operand) { - operand.values[19] = OpcodeCodings223_19; + operand.values[19] = OpcodeCodings225_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode224(x64Operand &operand) +asmError x64Parser::Opcode226(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6739, operand); + asmError rv = ParseOperands(tokenBranches6745, operand); return rv; } -Coding x64Parser::OpcodeCodings225_19[] = { +Coding x64Parser::OpcodeCodings227_19[] = { { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode225(x64Operand &operand) +asmError x64Parser::Opcode227(x64Operand &operand) { - operand.values[19] = OpcodeCodings225_19; + operand.values[19] = OpcodeCodings227_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings226_38[] = { +Coding x64Parser::OpcodeCodings228_38[] = { { CODING_NAME("ja") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode226(x64Operand &operand) +asmError x64Parser::Opcode228(x64Operand &operand) { - operand.values[38] = OpcodeCodings226_38; + operand.values[38] = OpcodeCodings228_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings227_38[] = { +Coding x64Parser::OpcodeCodings229_38[] = { { CODING_NAME("jae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode227(x64Operand &operand) +asmError x64Parser::Opcode229(x64Operand &operand) { - operand.values[38] = OpcodeCodings227_38; + operand.values[38] = OpcodeCodings229_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings228_38[] = { +Coding x64Parser::OpcodeCodings230_38[] = { { CODING_NAME("jb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode228(x64Operand &operand) +asmError x64Parser::Opcode230(x64Operand &operand) { - operand.values[38] = OpcodeCodings228_38; + operand.values[38] = OpcodeCodings230_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings229_38[] = { +Coding x64Parser::OpcodeCodings231_38[] = { { CODING_NAME("jbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode229(x64Operand &operand) +asmError x64Parser::Opcode231(x64Operand &operand) { - operand.values[38] = OpcodeCodings229_38; + operand.values[38] = OpcodeCodings231_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings230_38[] = { +Coding x64Parser::OpcodeCodings232_38[] = { { CODING_NAME("jc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode230(x64Operand &operand) +asmError x64Parser::Opcode232(x64Operand &operand) { - operand.values[38] = OpcodeCodings230_38; + operand.values[38] = OpcodeCodings232_38; asmError rv; { rv = Opcode12(operand); } return rv; } -asmError x64Parser::Opcode231(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6747, operand); - return rv; -} -asmError x64Parser::Opcode232(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6749, operand); - return rv; -} -Coding x64Parser::OpcodeCodings233_38[] = { - { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode233(x64Operand &operand) { - operand.values[38] = OpcodeCodings233_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6753, operand); return rv; } -Coding x64Parser::OpcodeCodings234_38[] = { - { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode234(x64Operand &operand) { - operand.values[38] = OpcodeCodings234_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6755, operand); return rv; } Coding x64Parser::OpcodeCodings235_38[] = { - { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode235(x64Operand &operand) @@ -40749,7 +40802,7 @@ asmError x64Parser::Opcode235(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings236_38[] = { - { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode236(x64Operand &operand) @@ -40762,7 +40815,7 @@ asmError x64Parser::Opcode236(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings237_38[] = { - { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode237(x64Operand &operand) @@ -40774,13 +40827,21 @@ asmError x64Parser::Opcode237(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings238_38[] = { + { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode238(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6756, operand); + operand.values[38] = OpcodeCodings238_38; + asmError rv; + { + rv = Opcode12(operand); + } return rv; } Coding x64Parser::OpcodeCodings239_38[] = { - { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode239(x64Operand &operand) @@ -40792,21 +40853,13 @@ asmError x64Parser::Opcode239(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings240_38[] = { - { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode240(x64Operand &operand) { - operand.values[38] = OpcodeCodings240_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6762, operand); return rv; } Coding x64Parser::OpcodeCodings241_38[] = { - { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode241(x64Operand &operand) @@ -40819,7 +40872,7 @@ asmError x64Parser::Opcode241(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings242_38[] = { - { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode242(x64Operand &operand) @@ -40832,7 +40885,7 @@ asmError x64Parser::Opcode242(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings243_38[] = { - { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode243(x64Operand &operand) @@ -40845,7 +40898,7 @@ asmError x64Parser::Opcode243(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings244_38[] = { - { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode244(x64Operand &operand) @@ -40858,7 +40911,7 @@ asmError x64Parser::Opcode244(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings245_38[] = { - { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode245(x64Operand &operand) @@ -40871,7 +40924,7 @@ asmError x64Parser::Opcode245(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings246_38[] = { - { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode246(x64Operand &operand) @@ -40884,7 +40937,7 @@ asmError x64Parser::Opcode246(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings247_38[] = { - { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode247(x64Operand &operand) @@ -40897,7 +40950,7 @@ asmError x64Parser::Opcode247(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings248_38[] = { - { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode248(x64Operand &operand) @@ -40910,7 +40963,7 @@ asmError x64Parser::Opcode248(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings249_38[] = { - { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode249(x64Operand &operand) @@ -40923,7 +40976,7 @@ asmError x64Parser::Opcode249(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings250_38[] = { - { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode250(x64Operand &operand) @@ -40936,7 +40989,7 @@ asmError x64Parser::Opcode250(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings251_38[] = { - { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode251(x64Operand &operand) @@ -40949,7 +41002,7 @@ asmError x64Parser::Opcode251(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings252_38[] = { - { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode252(x64Operand &operand) @@ -40962,7 +41015,7 @@ asmError x64Parser::Opcode252(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings253_38[] = { - { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode253(x64Operand &operand) @@ -40975,7 +41028,7 @@ asmError x64Parser::Opcode253(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings254_38[] = { - { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode254(x64Operand &operand) @@ -40988,7 +41041,7 @@ asmError x64Parser::Opcode254(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings255_38[] = { - { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode255(x64Operand &operand) @@ -41001,7 +41054,7 @@ asmError x64Parser::Opcode255(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings256_38[] = { - { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode256(x64Operand &operand) @@ -41014,7 +41067,7 @@ asmError x64Parser::Opcode256(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings257_38[] = { - { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode257(x64Operand &operand) @@ -41027,7 +41080,7 @@ asmError x64Parser::Opcode257(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings258_38[] = { - { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode258(x64Operand &operand) @@ -41039,1044 +41092,1044 @@ asmError x64Parser::Opcode258(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings259_19[] = { - { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings259_38[] = { + { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode259(x64Operand &operand) { - operand.values[19] = OpcodeCodings259_19; + operand.values[38] = OpcodeCodings259_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings260_38[] = { + { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode260(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings260_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings261_19[] = { + { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode261(x64Operand &operand) +{ + operand.values[19] = OpcodeCodings261_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings260_36[] = { +Coding x64Parser::OpcodeCodings262_36[] = { { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode260(x64Operand &operand) +asmError x64Parser::Opcode262(x64Operand &operand) { - operand.values[36] = OpcodeCodings260_36; + operand.values[36] = OpcodeCodings262_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings261_36[] = { +Coding x64Parser::OpcodeCodings263_36[] = { { CODING_NAME("lds") Coding::stateFunc, 7 }, { CODING_NAME("lds") (Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode261(x64Operand &operand) +asmError x64Parser::Opcode263(x64Operand &operand) { - operand.values[36] = OpcodeCodings261_36; + operand.values[36] = OpcodeCodings263_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings262_36[] = { +Coding x64Parser::OpcodeCodings264_36[] = { { CODING_NAME("lea") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode262(x64Operand &operand) +asmError x64Parser::Opcode264(x64Operand &operand) { - operand.values[36] = OpcodeCodings262_36; + operand.values[36] = OpcodeCodings264_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings263_19[] = { +Coding x64Parser::OpcodeCodings265_19[] = { { CODING_NAME("leave") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode263(x64Operand &operand) +asmError x64Parser::Opcode265(x64Operand &operand) { - operand.values[19] = OpcodeCodings263_19; + operand.values[19] = OpcodeCodings265_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings264_36[] = { +Coding x64Parser::OpcodeCodings266_36[] = { { CODING_NAME("les") Coding::stateFunc, 7 }, { CODING_NAME("les") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode264(x64Operand &operand) +asmError x64Parser::Opcode266(x64Operand &operand) { - operand.values[36] = OpcodeCodings264_36; + operand.values[36] = OpcodeCodings266_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings265_19[] = { +Coding x64Parser::OpcodeCodings267_19[] = { { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode265(x64Operand &operand) +asmError x64Parser::Opcode267(x64Operand &operand) { - operand.values[19] = OpcodeCodings265_19; + operand.values[19] = OpcodeCodings267_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings266_36[] = { +Coding x64Parser::OpcodeCodings268_36[] = { { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode266(x64Operand &operand) +asmError x64Parser::Opcode268(x64Operand &operand) { - operand.values[36] = OpcodeCodings266_36; + operand.values[36] = OpcodeCodings268_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings267_18[] = { +Coding x64Parser::OpcodeCodings269_18[] = { { CODING_NAME("lgdt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings267_19[] = { +Coding x64Parser::OpcodeCodings269_19[] = { { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode267(x64Operand &operand) +asmError x64Parser::Opcode269(x64Operand &operand) { - operand.values[18] = OpcodeCodings267_18; - operand.values[19] = OpcodeCodings267_19; + operand.values[18] = OpcodeCodings269_18; + operand.values[19] = OpcodeCodings269_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings268_36[] = { +Coding x64Parser::OpcodeCodings270_36[] = { { CODING_NAME("lgs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lgs") (Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode268(x64Operand &operand) +asmError x64Parser::Opcode270(x64Operand &operand) { - operand.values[36] = OpcodeCodings268_36; + operand.values[36] = OpcodeCodings270_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings269_18[] = { +Coding x64Parser::OpcodeCodings271_18[] = { { CODING_NAME("lidt") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings269_19[] = { +Coding x64Parser::OpcodeCodings271_19[] = { { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode269(x64Operand &operand) +asmError x64Parser::Opcode271(x64Operand &operand) { - operand.values[18] = OpcodeCodings269_18; - operand.values[19] = OpcodeCodings269_19; + operand.values[18] = OpcodeCodings271_18; + operand.values[19] = OpcodeCodings271_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings270_18[] = { +Coding x64Parser::OpcodeCodings272_18[] = { { CODING_NAME("lldt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings270_19[] = { +Coding x64Parser::OpcodeCodings272_19[] = { { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode270(x64Operand &operand) +asmError x64Parser::Opcode272(x64Operand &operand) { - operand.values[18] = OpcodeCodings270_18; - operand.values[19] = OpcodeCodings270_19; + operand.values[18] = OpcodeCodings272_18; + operand.values[19] = OpcodeCodings272_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings271_18[] = { +Coding x64Parser::OpcodeCodings273_18[] = { { CODING_NAME("lmsw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings271_19[] = { +Coding x64Parser::OpcodeCodings273_19[] = { { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode271(x64Operand &operand) +asmError x64Parser::Opcode273(x64Operand &operand) { - operand.values[18] = OpcodeCodings271_18; - operand.values[19] = OpcodeCodings271_19; - asmError rv = ParseOperands(tokenBranches6829, operand); + operand.values[18] = OpcodeCodings273_18; + operand.values[19] = OpcodeCodings273_19; + asmError rv = ParseOperands(tokenBranches6835, operand); return rv; } -asmError x64Parser::Opcode272(x64Operand &operand) +asmError x64Parser::Opcode274(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6831, operand); + asmError rv = ParseOperands(tokenBranches6837, operand); return rv; } -Coding x64Parser::OpcodeCodings273_19[] = { +Coding x64Parser::OpcodeCodings275_19[] = { { CODING_NAME("lodsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode273(x64Operand &operand) +asmError x64Parser::Opcode275(x64Operand &operand) { - operand.values[19] = OpcodeCodings273_19; + operand.values[19] = OpcodeCodings275_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings274_19[] = { +Coding x64Parser::OpcodeCodings276_19[] = { { CODING_NAME("lodsw") Coding::stateFunc, 4 }, { CODING_NAME("lodsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode274(x64Operand &operand) +asmError x64Parser::Opcode276(x64Operand &operand) { - operand.values[19] = OpcodeCodings274_19; + operand.values[19] = OpcodeCodings276_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings275_19[] = { +Coding x64Parser::OpcodeCodings277_19[] = { { CODING_NAME("lodsd") Coding::stateFunc, 5 }, { CODING_NAME("lodsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode275(x64Operand &operand) +asmError x64Parser::Opcode277(x64Operand &operand) { - operand.values[19] = OpcodeCodings275_19; + operand.values[19] = OpcodeCodings277_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode276(x64Operand &operand) +asmError x64Parser::Opcode278(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6959, operand); + asmError rv = ParseOperands(tokenBranches6965, operand); return rv; } -asmError x64Parser::Opcode277(x64Operand &operand) +asmError x64Parser::Opcode279(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6961, operand); + asmError rv = ParseOperands(tokenBranches6967, operand); return rv; } -asmError x64Parser::Opcode278(x64Operand &operand) +asmError x64Parser::Opcode280(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6963, operand); + asmError rv = ParseOperands(tokenBranches6969, operand); return rv; } -asmError x64Parser::Opcode279(x64Operand &operand) +asmError x64Parser::Opcode281(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6965, operand); + asmError rv = ParseOperands(tokenBranches6971, operand); return rv; } -asmError x64Parser::Opcode280(x64Operand &operand) +asmError x64Parser::Opcode282(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6967, operand); + asmError rv = ParseOperands(tokenBranches6973, operand); return rv; } -asmError x64Parser::Opcode281(x64Operand &operand) +asmError x64Parser::Opcode283(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6969, operand); + asmError rv = ParseOperands(tokenBranches6975, operand); return rv; } -Coding x64Parser::OpcodeCodings282_36[] = { +Coding x64Parser::OpcodeCodings284_36[] = { { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode282(x64Operand &operand) +asmError x64Parser::Opcode284(x64Operand &operand) { - operand.values[36] = OpcodeCodings282_36; + operand.values[36] = OpcodeCodings284_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings283_36[] = { +Coding x64Parser::OpcodeCodings285_36[] = { { CODING_NAME("lss") Coding::stateFunc, 7 }, { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode283(x64Operand &operand) +asmError x64Parser::Opcode285(x64Operand &operand) { - operand.values[36] = OpcodeCodings283_36; + operand.values[36] = OpcodeCodings285_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings284_18[] = { +Coding x64Parser::OpcodeCodings286_18[] = { { CODING_NAME("ltr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings284_19[] = { +Coding x64Parser::OpcodeCodings286_19[] = { { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode284(x64Operand &operand) +asmError x64Parser::Opcode286(x64Operand &operand) { - operand.values[18] = OpcodeCodings284_18; - operand.values[19] = OpcodeCodings284_19; - asmError rv = ParseOperands(tokenBranches6973, operand); + operand.values[18] = OpcodeCodings286_18; + operand.values[19] = OpcodeCodings286_19; + asmError rv = ParseOperands(tokenBranches6979, operand); if (rv == AERR_NONE) { rv = Opcode18(operand); } return rv; } -asmError x64Parser::Opcode285(x64Operand &operand) +asmError x64Parser::Opcode287(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6975, operand); + asmError rv = ParseOperands(tokenBranches6981, operand); return rv; } -asmError x64Parser::Opcode286(x64Operand &operand) +asmError x64Parser::Opcode288(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7284, operand); + asmError rv = ParseOperands(tokenBranches7290, operand); return rv; } -Coding x64Parser::OpcodeCodings287_36[] = { +Coding x64Parser::OpcodeCodings289_36[] = { { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode287(x64Operand &operand) +asmError x64Parser::Opcode289(x64Operand &operand) { - operand.values[36] = OpcodeCodings287_36; - asmError rv = ParseOperands(tokenBranches7547, operand); + operand.values[36] = OpcodeCodings289_36; + asmError rv = ParseOperands(tokenBranches7553, operand); return rv; } -Coding x64Parser::OpcodeCodings288_19[] = { +Coding x64Parser::OpcodeCodings290_19[] = { { CODING_NAME("movsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode288(x64Operand &operand) +asmError x64Parser::Opcode290(x64Operand &operand) { - operand.values[19] = OpcodeCodings288_19; + operand.values[19] = OpcodeCodings290_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings289_19[] = { +Coding x64Parser::OpcodeCodings291_19[] = { { CODING_NAME("movsw") Coding::stateFunc, 4 }, { CODING_NAME("movsw") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode289(x64Operand &operand) +asmError x64Parser::Opcode291(x64Operand &operand) { - operand.values[19] = OpcodeCodings289_19; + operand.values[19] = OpcodeCodings291_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode290(x64Operand &operand) +asmError x64Parser::Opcode292(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7574, operand); + asmError rv = ParseOperands(tokenBranches7580, operand); return rv; } -asmError x64Parser::Opcode291(x64Operand &operand) +asmError x64Parser::Opcode293(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7582, operand); + asmError rv = ParseOperands(tokenBranches7588, operand); return rv; } -Coding x64Parser::OpcodeCodings292_36[] = { +Coding x64Parser::OpcodeCodings294_36[] = { { CODING_NAME("movsx") (Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode292(x64Operand &operand) +asmError x64Parser::Opcode294(x64Operand &operand) { - operand.values[36] = OpcodeCodings292_36; + operand.values[36] = OpcodeCodings294_36; asmError rv; { rv = Opcode15(operand); } return rv; } -Coding x64Parser::OpcodeCodings293_36[] = { +Coding x64Parser::OpcodeCodings295_36[] = { { CODING_NAME("movzx") (Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode293(x64Operand &operand) +asmError x64Parser::Opcode295(x64Operand &operand) { - operand.values[36] = OpcodeCodings293_36; + operand.values[36] = OpcodeCodings295_36; asmError rv; { rv = Opcode15(operand); } return rv; } -asmError x64Parser::Opcode294(x64Operand &operand) +asmError x64Parser::Opcode296(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7586, operand); + asmError rv = ParseOperands(tokenBranches7592, operand); return rv; } -Coding x64Parser::OpcodeCodings295_18[] = { +Coding x64Parser::OpcodeCodings297_18[] = { { CODING_NAME("mul") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode295(x64Operand &operand) +asmError x64Parser::Opcode297(x64Operand &operand) { - operand.values[18] = OpcodeCodings295_18; + operand.values[18] = OpcodeCodings297_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings296_18[] = { +Coding x64Parser::OpcodeCodings298_18[] = { { CODING_NAME("neg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode296(x64Operand &operand) +asmError x64Parser::Opcode298(x64Operand &operand) { - operand.values[18] = OpcodeCodings296_18; + operand.values[18] = OpcodeCodings298_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings297_19[] = { +Coding x64Parser::OpcodeCodings299_19[] = { { CODING_NAME("nop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode297(x64Operand &operand) +asmError x64Parser::Opcode299(x64Operand &operand) { - operand.values[19] = OpcodeCodings297_19; + operand.values[19] = OpcodeCodings299_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings298_18[] = { +Coding x64Parser::OpcodeCodings300_18[] = { { CODING_NAME("not") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode298(x64Operand &operand) +asmError x64Parser::Opcode300(x64Operand &operand) { - operand.values[18] = OpcodeCodings298_18; + operand.values[18] = OpcodeCodings300_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings299_18[] = { +Coding x64Parser::OpcodeCodings301_18[] = { { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings299_36[] = { +Coding x64Parser::OpcodeCodings301_36[] = { { CODING_NAME("or") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings299_37[] = { +Coding x64Parser::OpcodeCodings301_37[] = { { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode299(x64Operand &operand) +asmError x64Parser::Opcode301(x64Operand &operand) { - operand.values[18] = OpcodeCodings299_18; - operand.values[36] = OpcodeCodings299_36; - operand.values[37] = OpcodeCodings299_37; + operand.values[18] = OpcodeCodings301_18; + operand.values[36] = OpcodeCodings301_36; + operand.values[37] = OpcodeCodings301_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode300(x64Operand &operand) +asmError x64Parser::Opcode302(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7606, operand); + asmError rv = ParseOperands(tokenBranches7612, operand); return rv; } -asmError x64Parser::Opcode301(x64Operand &operand) +asmError x64Parser::Opcode303(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7635, operand); + asmError rv = ParseOperands(tokenBranches7641, operand); return rv; } -Coding x64Parser::OpcodeCodings302_19[] = { +Coding x64Parser::OpcodeCodings304_19[] = { { CODING_NAME("outsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode302(x64Operand &operand) +asmError x64Parser::Opcode304(x64Operand &operand) { - operand.values[19] = OpcodeCodings302_19; + operand.values[19] = OpcodeCodings304_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings303_19[] = { +Coding x64Parser::OpcodeCodings305_19[] = { { CODING_NAME("outsw") Coding::stateFunc, 4 }, { CODING_NAME("outsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode303(x64Operand &operand) +asmError x64Parser::Opcode305(x64Operand &operand) { - operand.values[19] = OpcodeCodings303_19; + operand.values[19] = OpcodeCodings305_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings304_19[] = { +Coding x64Parser::OpcodeCodings306_19[] = { { CODING_NAME("outsd") Coding::stateFunc, 5 }, { CODING_NAME("outsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode304(x64Operand &operand) +asmError x64Parser::Opcode306(x64Operand &operand) { - operand.values[19] = OpcodeCodings304_19; + operand.values[19] = OpcodeCodings306_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode305(x64Operand &operand) +asmError x64Parser::Opcode307(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7777, operand); + asmError rv = ParseOperands(tokenBranches7783, operand); return rv; } -Coding x64Parser::OpcodeCodings306_19[] = { +Coding x64Parser::OpcodeCodings308_19[] = { { CODING_NAME("popa") Coding::stateFunc, 7 }, { CODING_NAME("popa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode306(x64Operand &operand) +asmError x64Parser::Opcode308(x64Operand &operand) { - operand.values[19] = OpcodeCodings306_19; + operand.values[19] = OpcodeCodings308_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings307_19[] = { +Coding x64Parser::OpcodeCodings309_19[] = { { CODING_NAME("popaw") Coding::stateFunc, 7 }, { CODING_NAME("popaw") Coding::stateFunc, 4 }, { CODING_NAME("popaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode307(x64Operand &operand) +asmError x64Parser::Opcode309(x64Operand &operand) { - operand.values[19] = OpcodeCodings307_19; + operand.values[19] = OpcodeCodings309_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings308_19[] = { +Coding x64Parser::OpcodeCodings310_19[] = { { CODING_NAME("popad") Coding::stateFunc, 7 }, { CODING_NAME("popad") Coding::stateFunc, 5 }, { CODING_NAME("popad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode308(x64Operand &operand) +asmError x64Parser::Opcode310(x64Operand &operand) { - operand.values[19] = OpcodeCodings308_19; + operand.values[19] = OpcodeCodings310_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings309_23[] = { +Coding x64Parser::OpcodeCodings311_23[] = { { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings309_36[] = { +Coding x64Parser::OpcodeCodings311_36[] = { { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode309(x64Operand &operand) +asmError x64Parser::Opcode311(x64Operand &operand) { - operand.values[23] = OpcodeCodings309_23; - operand.values[36] = OpcodeCodings309_36; + operand.values[23] = OpcodeCodings311_23; + operand.values[36] = OpcodeCodings311_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings310_19[] = { +Coding x64Parser::OpcodeCodings312_19[] = { { CODING_NAME("popf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode310(x64Operand &operand) +asmError x64Parser::Opcode312(x64Operand &operand) { - operand.values[19] = OpcodeCodings310_19; + operand.values[19] = OpcodeCodings312_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings311_19[] = { +Coding x64Parser::OpcodeCodings313_19[] = { { CODING_NAME("popfw") Coding::stateFunc, 4 }, { CODING_NAME("popfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode311(x64Operand &operand) +asmError x64Parser::Opcode313(x64Operand &operand) { - operand.values[19] = OpcodeCodings311_19; + operand.values[19] = OpcodeCodings313_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings312_19[] = { +Coding x64Parser::OpcodeCodings314_19[] = { { CODING_NAME("popfd") Coding::stateFunc, 5 }, { CODING_NAME("popfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode312(x64Operand &operand) +asmError x64Parser::Opcode314(x64Operand &operand) { - operand.values[19] = OpcodeCodings312_19; + operand.values[19] = OpcodeCodings314_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings313_19[] = { +Coding x64Parser::OpcodeCodings315_19[] = { { CODING_NAME("popfq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode313(x64Operand &operand) +asmError x64Parser::Opcode315(x64Operand &operand) { - operand.values[19] = OpcodeCodings313_19; + operand.values[19] = OpcodeCodings315_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode314(x64Operand &operand) +asmError x64Parser::Opcode316(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7798, operand); + asmError rv = ParseOperands(tokenBranches7804, operand); return rv; } -asmError x64Parser::Opcode315(x64Operand &operand) +asmError x64Parser::Opcode317(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7800, operand); + asmError rv = ParseOperands(tokenBranches7806, operand); return rv; } -asmError x64Parser::Opcode316(x64Operand &operand) +asmError x64Parser::Opcode318(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7802, operand); + asmError rv = ParseOperands(tokenBranches7808, operand); return rv; } -asmError x64Parser::Opcode317(x64Operand &operand) +asmError x64Parser::Opcode319(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7804, operand); + asmError rv = ParseOperands(tokenBranches7810, operand); return rv; } -asmError x64Parser::Opcode318(x64Operand &operand) +asmError x64Parser::Opcode320(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7806, operand); + asmError rv = ParseOperands(tokenBranches7812, operand); return rv; } -Coding x64Parser::OpcodeCodings319_19[] = { +Coding x64Parser::OpcodeCodings321_19[] = { { CODING_NAME("pusha") Coding::stateFunc, 7 }, { CODING_NAME("pusha") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode319(x64Operand &operand) +asmError x64Parser::Opcode321(x64Operand &operand) { - operand.values[19] = OpcodeCodings319_19; + operand.values[19] = OpcodeCodings321_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings320_19[] = { +Coding x64Parser::OpcodeCodings322_19[] = { { CODING_NAME("pushaw") Coding::stateFunc, 7 }, { CODING_NAME("pushaw") Coding::stateFunc, 4 }, { CODING_NAME("pushaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode320(x64Operand &operand) +asmError x64Parser::Opcode322(x64Operand &operand) { - operand.values[19] = OpcodeCodings320_19; + operand.values[19] = OpcodeCodings322_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings321_19[] = { +Coding x64Parser::OpcodeCodings323_19[] = { { CODING_NAME("pushad") Coding::stateFunc, 7 }, { CODING_NAME("pushad") Coding::stateFunc, 5 }, { CODING_NAME("pushad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode321(x64Operand &operand) +asmError x64Parser::Opcode323(x64Operand &operand) { - operand.values[19] = OpcodeCodings321_19; + operand.values[19] = OpcodeCodings323_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings322_19[] = { +Coding x64Parser::OpcodeCodings324_19[] = { { CODING_NAME("pushf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode322(x64Operand &operand) +asmError x64Parser::Opcode324(x64Operand &operand) { - operand.values[19] = OpcodeCodings322_19; + operand.values[19] = OpcodeCodings324_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings323_19[] = { +Coding x64Parser::OpcodeCodings325_19[] = { { CODING_NAME("pushfw") Coding::stateFunc, 4 }, { CODING_NAME("pushfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode323(x64Operand &operand) +asmError x64Parser::Opcode325(x64Operand &operand) { - operand.values[19] = OpcodeCodings323_19; + operand.values[19] = OpcodeCodings325_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings324_19[] = { +Coding x64Parser::OpcodeCodings326_19[] = { { CODING_NAME("pushfd") Coding::stateFunc, 5 }, { CODING_NAME("pushfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode324(x64Operand &operand) +asmError x64Parser::Opcode326(x64Operand &operand) { - operand.values[19] = OpcodeCodings324_19; + operand.values[19] = OpcodeCodings326_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings325_19[] = { +Coding x64Parser::OpcodeCodings327_19[] = { { CODING_NAME("pushfq") (Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode325(x64Operand &operand) +asmError x64Parser::Opcode327(x64Operand &operand) { - operand.values[19] = OpcodeCodings325_19; + operand.values[19] = OpcodeCodings327_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings326_18[] = { +Coding x64Parser::OpcodeCodings328_18[] = { { CODING_NAME("rcl") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode326(x64Operand &operand) +asmError x64Parser::Opcode328(x64Operand &operand) { - operand.values[18] = OpcodeCodings326_18; + operand.values[18] = OpcodeCodings328_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings327_18[] = { +Coding x64Parser::OpcodeCodings329_18[] = { { CODING_NAME("rcr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode327(x64Operand &operand) +asmError x64Parser::Opcode329(x64Operand &operand) { - operand.values[18] = OpcodeCodings327_18; + operand.values[18] = OpcodeCodings329_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings328_19[] = { +Coding x64Parser::OpcodeCodings330_19[] = { { CODING_NAME("rdmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode328(x64Operand &operand) +asmError x64Parser::Opcode330(x64Operand &operand) { - operand.values[19] = OpcodeCodings328_19; + operand.values[19] = OpcodeCodings330_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings329_19[] = { +Coding x64Parser::OpcodeCodings331_19[] = { { CODING_NAME("rdpmc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode329(x64Operand &operand) +asmError x64Parser::Opcode331(x64Operand &operand) { - operand.values[19] = OpcodeCodings329_19; + operand.values[19] = OpcodeCodings331_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings330_19[] = { +Coding x64Parser::OpcodeCodings332_19[] = { { CODING_NAME("rdtsc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode330(x64Operand &operand) +asmError x64Parser::Opcode332(x64Operand &operand) { - operand.values[19] = OpcodeCodings330_19; + operand.values[19] = OpcodeCodings332_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode331(x64Operand &operand) +asmError x64Parser::Opcode333(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7842, operand); + asmError rv = ParseOperands(tokenBranches7848, operand); return rv; } -asmError x64Parser::Opcode332(x64Operand &operand) +asmError x64Parser::Opcode334(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7845, operand); + asmError rv = ParseOperands(tokenBranches7851, operand); return rv; } -Coding x64Parser::OpcodeCodings333_18[] = { +Coding x64Parser::OpcodeCodings335_18[] = { { CODING_NAME("rol") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode333(x64Operand &operand) +asmError x64Parser::Opcode335(x64Operand &operand) { - operand.values[18] = OpcodeCodings333_18; + operand.values[18] = OpcodeCodings335_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings334_18[] = { +Coding x64Parser::OpcodeCodings336_18[] = { { CODING_NAME("ror") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode334(x64Operand &operand) +asmError x64Parser::Opcode336(x64Operand &operand) { - operand.values[18] = OpcodeCodings334_18; + operand.values[18] = OpcodeCodings336_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings335_19[] = { +Coding x64Parser::OpcodeCodings337_19[] = { { CODING_NAME("rsm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode335(x64Operand &operand) +asmError x64Parser::Opcode337(x64Operand &operand) { - operand.values[19] = OpcodeCodings335_19; + operand.values[19] = OpcodeCodings337_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings336_19[] = { +Coding x64Parser::OpcodeCodings338_19[] = { { CODING_NAME("sahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode336(x64Operand &operand) +asmError x64Parser::Opcode338(x64Operand &operand) { - operand.values[19] = OpcodeCodings336_19; + operand.values[19] = OpcodeCodings338_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings337_18[] = { +Coding x64Parser::OpcodeCodings339_18[] = { { CODING_NAME("sal") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode337(x64Operand &operand) +asmError x64Parser::Opcode339(x64Operand &operand) { - operand.values[18] = OpcodeCodings337_18; + operand.values[18] = OpcodeCodings339_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings338_18[] = { +Coding x64Parser::OpcodeCodings340_18[] = { { CODING_NAME("sar") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode338(x64Operand &operand) +asmError x64Parser::Opcode340(x64Operand &operand) { - operand.values[18] = OpcodeCodings338_18; + operand.values[18] = OpcodeCodings340_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings339_18[] = { +Coding x64Parser::OpcodeCodings341_18[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings339_36[] = { +Coding x64Parser::OpcodeCodings341_36[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings339_37[] = { +Coding x64Parser::OpcodeCodings341_37[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode339(x64Operand &operand) +asmError x64Parser::Opcode341(x64Operand &operand) { - operand.values[18] = OpcodeCodings339_18; - operand.values[36] = OpcodeCodings339_36; - operand.values[37] = OpcodeCodings339_37; + operand.values[18] = OpcodeCodings341_18; + operand.values[36] = OpcodeCodings341_36; + operand.values[37] = OpcodeCodings341_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode340(x64Operand &operand) +asmError x64Parser::Opcode342(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7855, operand); + asmError rv = ParseOperands(tokenBranches7861, operand); return rv; } -Coding x64Parser::OpcodeCodings341_19[] = { +Coding x64Parser::OpcodeCodings343_19[] = { { CODING_NAME("scasb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode341(x64Operand &operand) +asmError x64Parser::Opcode343(x64Operand &operand) { - operand.values[19] = OpcodeCodings341_19; + operand.values[19] = OpcodeCodings343_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings342_19[] = { +Coding x64Parser::OpcodeCodings344_19[] = { { CODING_NAME("scasw") Coding::stateFunc, 4 }, { CODING_NAME("scasw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode342(x64Operand &operand) +asmError x64Parser::Opcode344(x64Operand &operand) { - operand.values[19] = OpcodeCodings342_19; + operand.values[19] = OpcodeCodings344_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings343_19[] = { +Coding x64Parser::OpcodeCodings345_19[] = { { CODING_NAME("scasd") Coding::stateFunc, 5 }, { CODING_NAME("scasd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode343(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings343_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; -} -asmError x64Parser::Opcode344(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches7983, operand); - return rv; -} -Coding x64Parser::OpcodeCodings345_38[] = { - { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode345(x64Operand &operand) { - operand.values[38] = OpcodeCodings345_38; + operand.values[19] = OpcodeCodings345_19; asmError rv; { - rv = Opcode14(operand); + rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings346_38[] = { - { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode346(x64Operand &operand) { - operand.values[38] = OpcodeCodings346_38; - asmError rv; - { - rv = Opcode14(operand); - } + asmError rv = ParseOperands(tokenBranches7989, operand); return rv; } Coding x64Parser::OpcodeCodings347_38[] = { - { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode347(x64Operand &operand) @@ -42089,7 +42142,7 @@ asmError x64Parser::Opcode347(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings348_38[] = { - { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode348(x64Operand &operand) @@ -42102,7 +42155,7 @@ asmError x64Parser::Opcode348(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings349_38[] = { - { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode349(x64Operand &operand) @@ -42115,7 +42168,7 @@ asmError x64Parser::Opcode349(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings350_38[] = { - { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode350(x64Operand &operand) @@ -42128,7 +42181,7 @@ asmError x64Parser::Opcode350(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings351_38[] = { - { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode351(x64Operand &operand) @@ -42141,7 +42194,7 @@ asmError x64Parser::Opcode351(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings352_38[] = { - { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode352(x64Operand &operand) @@ -42154,7 +42207,7 @@ asmError x64Parser::Opcode352(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings353_38[] = { - { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode353(x64Operand &operand) @@ -42167,7 +42220,7 @@ asmError x64Parser::Opcode353(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings354_38[] = { - { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode354(x64Operand &operand) @@ -42180,7 +42233,7 @@ asmError x64Parser::Opcode354(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings355_38[] = { - { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode355(x64Operand &operand) @@ -42193,7 +42246,7 @@ asmError x64Parser::Opcode355(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings356_38[] = { - { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode356(x64Operand &operand) @@ -42206,7 +42259,7 @@ asmError x64Parser::Opcode356(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings357_38[] = { - { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode357(x64Operand &operand) @@ -42219,7 +42272,7 @@ asmError x64Parser::Opcode357(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings358_38[] = { - { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode358(x64Operand &operand) @@ -42232,7 +42285,7 @@ asmError x64Parser::Opcode358(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings359_38[] = { - { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode359(x64Operand &operand) @@ -42245,7 +42298,7 @@ asmError x64Parser::Opcode359(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings360_38[] = { - { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode360(x64Operand &operand) @@ -42258,7 +42311,7 @@ asmError x64Parser::Opcode360(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings361_38[] = { - { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode361(x64Operand &operand) @@ -42271,7 +42324,7 @@ asmError x64Parser::Opcode361(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings362_38[] = { - { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode362(x64Operand &operand) @@ -42284,7 +42337,7 @@ asmError x64Parser::Opcode362(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings363_38[] = { - { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode363(x64Operand &operand) @@ -42297,7 +42350,7 @@ asmError x64Parser::Opcode363(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings364_38[] = { - { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode364(x64Operand &operand) @@ -42310,7 +42363,7 @@ asmError x64Parser::Opcode364(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings365_38[] = { - { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode365(x64Operand &operand) @@ -42323,7 +42376,7 @@ asmError x64Parser::Opcode365(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings366_38[] = { - { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode366(x64Operand &operand) @@ -42336,7 +42389,7 @@ asmError x64Parser::Opcode366(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings367_38[] = { - { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode367(x64Operand &operand) @@ -42349,7 +42402,7 @@ asmError x64Parser::Opcode367(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings368_38[] = { - { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode368(x64Operand &operand) @@ -42362,7 +42415,7 @@ asmError x64Parser::Opcode368(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings369_38[] = { - { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode369(x64Operand &operand) @@ -42375,7 +42428,7 @@ asmError x64Parser::Opcode369(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings370_38[] = { - { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode370(x64Operand &operand) @@ -42388,7 +42441,7 @@ asmError x64Parser::Opcode370(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings371_38[] = { - { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode371(x64Operand &operand) @@ -42401,7 +42454,7 @@ asmError x64Parser::Opcode371(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings372_38[] = { - { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode372(x64Operand &operand) @@ -42414,7 +42467,7 @@ asmError x64Parser::Opcode372(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings373_38[] = { - { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode373(x64Operand &operand) @@ -42427,7 +42480,7 @@ asmError x64Parser::Opcode373(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings374_38[] = { - { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode374(x64Operand &operand) @@ -42439,545 +42492,534 @@ asmError x64Parser::Opcode374(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings375_19[] = { +Coding x64Parser::OpcodeCodings375_38[] = { + { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode375(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings375_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings376_38[] = { + { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode376(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings376_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings377_19[] = { { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode375(x64Operand &operand) +asmError x64Parser::Opcode377(x64Operand &operand) { - operand.values[19] = OpcodeCodings375_19; + operand.values[19] = OpcodeCodings377_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings376_18[] = { +Coding x64Parser::OpcodeCodings378_18[] = { { CODING_NAME("sgdt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings376_19[] = { +Coding x64Parser::OpcodeCodings378_19[] = { { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode376(x64Operand &operand) +asmError x64Parser::Opcode378(x64Operand &operand) { - operand.values[18] = OpcodeCodings376_18; - operand.values[19] = OpcodeCodings376_19; + operand.values[18] = OpcodeCodings378_18; + operand.values[19] = OpcodeCodings378_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings377_18[] = { +Coding x64Parser::OpcodeCodings379_18[] = { { CODING_NAME("shl") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode377(x64Operand &operand) +asmError x64Parser::Opcode379(x64Operand &operand) { - operand.values[18] = OpcodeCodings377_18; + operand.values[18] = OpcodeCodings379_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings378_36[] = { +Coding x64Parser::OpcodeCodings380_36[] = { { CODING_NAME("shld") (Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode378(x64Operand &operand) +asmError x64Parser::Opcode380(x64Operand &operand) { - operand.values[36] = OpcodeCodings378_36; + operand.values[36] = OpcodeCodings380_36; asmError rv; { rv = Opcode17(operand); } return rv; } -Coding x64Parser::OpcodeCodings379_18[] = { +Coding x64Parser::OpcodeCodings381_18[] = { { CODING_NAME("shr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode379(x64Operand &operand) +asmError x64Parser::Opcode381(x64Operand &operand) { - operand.values[18] = OpcodeCodings379_18; + operand.values[18] = OpcodeCodings381_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings380_36[] = { +Coding x64Parser::OpcodeCodings382_36[] = { { CODING_NAME("shrd") (Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode380(x64Operand &operand) +asmError x64Parser::Opcode382(x64Operand &operand) { - operand.values[36] = OpcodeCodings380_36; + operand.values[36] = OpcodeCodings382_36; asmError rv; { rv = Opcode17(operand); } return rv; } -Coding x64Parser::OpcodeCodings381_18[] = { +Coding x64Parser::OpcodeCodings383_18[] = { { CODING_NAME("sidt") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings381_19[] = { +Coding x64Parser::OpcodeCodings383_19[] = { { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode381(x64Operand &operand) +asmError x64Parser::Opcode383(x64Operand &operand) { - operand.values[18] = OpcodeCodings381_18; - operand.values[19] = OpcodeCodings381_19; + operand.values[18] = OpcodeCodings383_18; + operand.values[19] = OpcodeCodings383_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings382_18[] = { +Coding x64Parser::OpcodeCodings384_18[] = { { CODING_NAME("sldt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings382_19[] = { +Coding x64Parser::OpcodeCodings384_19[] = { { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode382(x64Operand &operand) +asmError x64Parser::Opcode384(x64Operand &operand) { - operand.values[18] = OpcodeCodings382_18; - operand.values[19] = OpcodeCodings382_19; + operand.values[18] = OpcodeCodings384_18; + operand.values[19] = OpcodeCodings384_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings383_18[] = { +Coding x64Parser::OpcodeCodings385_18[] = { { CODING_NAME("smsw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings383_19[] = { +Coding x64Parser::OpcodeCodings385_19[] = { { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode383(x64Operand &operand) +asmError x64Parser::Opcode385(x64Operand &operand) { - operand.values[18] = OpcodeCodings383_18; - operand.values[19] = OpcodeCodings383_19; - asmError rv = ParseOperands(tokenBranches8023, operand); + operand.values[18] = OpcodeCodings385_18; + operand.values[19] = OpcodeCodings385_19; + asmError rv = ParseOperands(tokenBranches8029, operand); return rv; } -Coding x64Parser::OpcodeCodings384_19[] = { +Coding x64Parser::OpcodeCodings386_19[] = { { CODING_NAME("stc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode384(x64Operand &operand) +asmError x64Parser::Opcode386(x64Operand &operand) { - operand.values[19] = OpcodeCodings384_19; + operand.values[19] = OpcodeCodings386_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings385_19[] = { +Coding x64Parser::OpcodeCodings387_19[] = { { CODING_NAME("std") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode385(x64Operand &operand) +asmError x64Parser::Opcode387(x64Operand &operand) { - operand.values[19] = OpcodeCodings385_19; + operand.values[19] = OpcodeCodings387_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings386_19[] = { +Coding x64Parser::OpcodeCodings388_19[] = { { CODING_NAME("sti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode386(x64Operand &operand) +asmError x64Parser::Opcode388(x64Operand &operand) { - operand.values[19] = OpcodeCodings386_19; + operand.values[19] = OpcodeCodings388_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode387(x64Operand &operand) +asmError x64Parser::Opcode389(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8028, operand); + asmError rv = ParseOperands(tokenBranches8034, operand); return rv; } -Coding x64Parser::OpcodeCodings388_19[] = { +Coding x64Parser::OpcodeCodings390_19[] = { { CODING_NAME("stosb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode388(x64Operand &operand) +asmError x64Parser::Opcode390(x64Operand &operand) { - operand.values[19] = OpcodeCodings388_19; + operand.values[19] = OpcodeCodings390_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings389_19[] = { +Coding x64Parser::OpcodeCodings391_19[] = { { CODING_NAME("stosw") Coding::stateFunc, 4 }, { CODING_NAME("stosw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode389(x64Operand &operand) +asmError x64Parser::Opcode391(x64Operand &operand) { - operand.values[19] = OpcodeCodings389_19; + operand.values[19] = OpcodeCodings391_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings390_19[] = { +Coding x64Parser::OpcodeCodings392_19[] = { { CODING_NAME("stosd") Coding::stateFunc, 5 }, { CODING_NAME("stosd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode390(x64Operand &operand) +asmError x64Parser::Opcode392(x64Operand &operand) { - operand.values[19] = OpcodeCodings390_19; + operand.values[19] = OpcodeCodings392_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode391(x64Operand &operand) +asmError x64Parser::Opcode393(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8156, operand); + asmError rv = ParseOperands(tokenBranches8162, operand); return rv; } -Coding x64Parser::OpcodeCodings392_18[] = { +Coding x64Parser::OpcodeCodings394_18[] = { { CODING_NAME("str") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings392_19[] = { +Coding x64Parser::OpcodeCodings394_19[] = { { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode392(x64Operand &operand) +asmError x64Parser::Opcode394(x64Operand &operand) { - operand.values[18] = OpcodeCodings392_18; - operand.values[19] = OpcodeCodings392_19; - asmError rv = ParseOperands(tokenBranches8158, operand); + operand.values[18] = OpcodeCodings394_18; + operand.values[19] = OpcodeCodings394_19; + asmError rv = ParseOperands(tokenBranches8164, operand); return rv; } -Coding x64Parser::OpcodeCodings393_18[] = { +Coding x64Parser::OpcodeCodings395_18[] = { { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings393_36[] = { +Coding x64Parser::OpcodeCodings395_36[] = { { CODING_NAME("sub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings393_37[] = { +Coding x64Parser::OpcodeCodings395_37[] = { { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode393(x64Operand &operand) +asmError x64Parser::Opcode395(x64Operand &operand) { - operand.values[18] = OpcodeCodings393_18; - operand.values[36] = OpcodeCodings393_36; - operand.values[37] = OpcodeCodings393_37; + operand.values[18] = OpcodeCodings395_18; + operand.values[36] = OpcodeCodings395_36; + operand.values[37] = OpcodeCodings395_37; asmError rv; { rv = Opcode4(operand); } return rv; } -Coding x64Parser::OpcodeCodings394_19[] = { +Coding x64Parser::OpcodeCodings396_19[] = { { CODING_NAME("syscall") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode394(x64Operand &operand) +asmError x64Parser::Opcode396(x64Operand &operand) { - operand.values[19] = OpcodeCodings394_19; + operand.values[19] = OpcodeCodings396_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings395_19[] = { +Coding x64Parser::OpcodeCodings397_19[] = { { CODING_NAME("sysenter") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode395(x64Operand &operand) +asmError x64Parser::Opcode397(x64Operand &operand) { - operand.values[19] = OpcodeCodings395_19; + operand.values[19] = OpcodeCodings397_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings396_19[] = { +Coding x64Parser::OpcodeCodings398_19[] = { { CODING_NAME("sysexit") (Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode396(x64Operand &operand) +asmError x64Parser::Opcode398(x64Operand &operand) { - operand.values[19] = OpcodeCodings396_19; + operand.values[19] = OpcodeCodings398_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings397_19[] = { +Coding x64Parser::OpcodeCodings399_19[] = { { CODING_NAME("sysret") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode397(x64Operand &operand) +asmError x64Parser::Opcode399(x64Operand &operand) { - operand.values[19] = OpcodeCodings397_19; + operand.values[19] = OpcodeCodings399_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode398(x64Operand &operand) +asmError x64Parser::Opcode400(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8167, operand); + asmError rv = ParseOperands(tokenBranches8173, operand); return rv; } -Coding x64Parser::OpcodeCodings399_19[] = { +Coding x64Parser::OpcodeCodings401_19[] = { { CODING_NAME("ud2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode399(x64Operand &operand) +asmError x64Parser::Opcode401(x64Operand &operand) { - operand.values[19] = OpcodeCodings399_19; + operand.values[19] = OpcodeCodings401_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings400_18[] = { +Coding x64Parser::OpcodeCodings402_18[] = { { CODING_NAME("verr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings400_19[] = { +Coding x64Parser::OpcodeCodings402_19[] = { { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode400(x64Operand &operand) +asmError x64Parser::Opcode402(x64Operand &operand) { - operand.values[18] = OpcodeCodings400_18; - operand.values[19] = OpcodeCodings400_19; - asmError rv = ParseOperands(tokenBranches8282, operand); + operand.values[18] = OpcodeCodings402_18; + operand.values[19] = OpcodeCodings402_19; + asmError rv = ParseOperands(tokenBranches8288, operand); return rv; } -Coding x64Parser::OpcodeCodings401_18[] = { +Coding x64Parser::OpcodeCodings403_18[] = { { CODING_NAME("verw") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings401_19[] = { +Coding x64Parser::OpcodeCodings403_19[] = { { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode401(x64Operand &operand) +asmError x64Parser::Opcode403(x64Operand &operand) { - operand.values[18] = OpcodeCodings401_18; - operand.values[19] = OpcodeCodings401_19; - asmError rv = ParseOperands(tokenBranches8284, operand); + operand.values[18] = OpcodeCodings403_18; + operand.values[19] = OpcodeCodings403_19; + asmError rv = ParseOperands(tokenBranches8290, operand); return rv; } -Coding x64Parser::OpcodeCodings402_19[] = { +Coding x64Parser::OpcodeCodings404_19[] = { { CODING_NAME("wait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode402(x64Operand &operand) +asmError x64Parser::Opcode404(x64Operand &operand) { - operand.values[19] = OpcodeCodings402_19; + operand.values[19] = OpcodeCodings404_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings403_19[] = { +Coding x64Parser::OpcodeCodings405_19[] = { { CODING_NAME("wbinvd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode403(x64Operand &operand) +asmError x64Parser::Opcode405(x64Operand &operand) { - operand.values[19] = OpcodeCodings403_19; + operand.values[19] = OpcodeCodings405_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings404_19[] = { +Coding x64Parser::OpcodeCodings406_19[] = { { CODING_NAME("wrmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode404(x64Operand &operand) +asmError x64Parser::Opcode406(x64Operand &operand) { - operand.values[19] = OpcodeCodings404_19; + operand.values[19] = OpcodeCodings406_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode405(x64Operand &operand) +asmError x64Parser::Opcode407(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8289, operand); + asmError rv = ParseOperands(tokenBranches8295, operand); return rv; } -asmError x64Parser::Opcode406(x64Operand &operand) +asmError x64Parser::Opcode408(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8310, operand); + asmError rv = ParseOperands(tokenBranches8316, operand); return rv; } -asmError x64Parser::Opcode407(x64Operand &operand) +asmError x64Parser::Opcode409(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8369, operand); + asmError rv = ParseOperands(tokenBranches8375, operand); return rv; } -Coding x64Parser::OpcodeCodings408_19[] = { +Coding x64Parser::OpcodeCodings410_19[] = { { CODING_NAME("xlatb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode408(x64Operand &operand) +asmError x64Parser::Opcode410(x64Operand &operand) { - operand.values[19] = OpcodeCodings408_19; + operand.values[19] = OpcodeCodings410_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings409_18[] = { +Coding x64Parser::OpcodeCodings411_18[] = { { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings409_36[] = { +Coding x64Parser::OpcodeCodings411_36[] = { { CODING_NAME("xor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings409_37[] = { +Coding x64Parser::OpcodeCodings411_37[] = { { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode409(x64Operand &operand) +asmError x64Parser::Opcode411(x64Operand &operand) { - operand.values[18] = OpcodeCodings409_18; - operand.values[36] = OpcodeCodings409_36; - operand.values[37] = OpcodeCodings409_37; + operand.values[18] = OpcodeCodings411_18; + operand.values[36] = OpcodeCodings411_36; + operand.values[37] = OpcodeCodings411_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode410(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches8409, operand); - return rv; -} -asmError x64Parser::Opcode411(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches8411, operand); - return rv; -} asmError x64Parser::Opcode412(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8413, operand); + asmError rv = ParseOperands(tokenBranches8415, operand); return rv; } asmError x64Parser::Opcode413(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8415, operand); + asmError rv = ParseOperands(tokenBranches8417, operand); return rv; } -Coding x64Parser::OpcodeCodings414_19[] = { - { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, - { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode414(x64Operand &operand) { - operand.values[19] = OpcodeCodings414_19; - asmError rv; - { - rv = Opcode1(operand); - } + asmError rv = ParseOperands(tokenBranches8419, operand); return rv; } -Coding x64Parser::OpcodeCodings415_23[] = { - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings415_19[] = { - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode415(x64Operand &operand) { - operand.values[23] = OpcodeCodings415_23; - operand.values[19] = OpcodeCodings415_19; - asmError rv; - { - rv = Opcode19(operand); - } + asmError rv = ParseOperands(tokenBranches8421, operand); return rv; } -Coding x64Parser::OpcodeCodings416_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings416_19[] = { - { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode416(x64Operand &operand) { - operand.values[23] = OpcodeCodings416_23; operand.values[19] = OpcodeCodings416_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode1(operand); } return rv; } Coding x64Parser::OpcodeCodings417_23[] = { - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings417_19[] = { - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode417(x64Operand &operand) @@ -42991,12 +43033,11 @@ asmError x64Parser::Opcode417(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings418_23[] = { - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings418_19[] = { - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode418(x64Operand &operand) @@ -43010,12 +43051,12 @@ asmError x64Parser::Opcode418(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings419_23[] = { - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings419_19[] = { - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode419(x64Operand &operand) @@ -43029,12 +43070,12 @@ asmError x64Parser::Opcode419(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings420_23[] = { - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings420_19[] = { - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode420(x64Operand &operand) @@ -43048,12 +43089,12 @@ asmError x64Parser::Opcode420(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings421_23[] = { - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings421_19[] = { - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode421(x64Operand &operand) @@ -43067,11 +43108,12 @@ asmError x64Parser::Opcode421(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings422_23[] = { + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings422_19[] = { - { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode422(x64Operand &operand) @@ -43085,12 +43127,12 @@ asmError x64Parser::Opcode422(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings423_23[] = { - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings423_19[] = { - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode423(x64Operand &operand) @@ -43107,8 +43149,8 @@ Coding x64Parser::OpcodeCodings424_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings424_19[] = { - { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode424(x64Operand &operand) @@ -43122,13 +43164,12 @@ asmError x64Parser::Opcode424(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings425_23[] = { - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings425_19[] = { - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode425(x64Operand &operand) @@ -43137,18 +43178,16 @@ asmError x64Parser::Opcode425(x64Operand &operand) operand.values[19] = OpcodeCodings425_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings426_23[] = { - { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings426_19[] = { - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode426(x64Operand &operand) @@ -43157,17 +43196,18 @@ asmError x64Parser::Opcode426(x64Operand &operand) operand.values[19] = OpcodeCodings426_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings427_23[] = { - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings427_19[] = { - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode427(x64Operand &operand) @@ -43176,16 +43216,18 @@ asmError x64Parser::Opcode427(x64Operand &operand) operand.values[19] = OpcodeCodings427_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings428_23[] = { + { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings428_19[] = { - { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode428(x64Operand &operand) @@ -43194,17 +43236,17 @@ asmError x64Parser::Opcode428(x64Operand &operand) operand.values[19] = OpcodeCodings428_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings429_23[] = { - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings429_19[] = { - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode429(x64Operand &operand) @@ -43213,7 +43255,7 @@ asmError x64Parser::Opcode429(x64Operand &operand) operand.values[19] = OpcodeCodings429_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode28(operand); } return rv; } @@ -43221,8 +43263,8 @@ Coding x64Parser::OpcodeCodings430_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings430_19[] = { - { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode430(x64Operand &operand) @@ -43231,17 +43273,17 @@ asmError x64Parser::Opcode430(x64Operand &operand) operand.values[19] = OpcodeCodings430_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode28(operand); } return rv; } Coding x64Parser::OpcodeCodings431_23[] = { - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings431_19[] = { - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode431(x64Operand &operand) @@ -43258,8 +43300,8 @@ Coding x64Parser::OpcodeCodings432_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings432_19[] = { - { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode432(x64Operand &operand) @@ -43273,12 +43315,12 @@ asmError x64Parser::Opcode432(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings433_23[] = { - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings433_19[] = { - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode433(x64Operand &operand) @@ -43292,12 +43334,11 @@ asmError x64Parser::Opcode433(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings434_23[] = { - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings434_19[] = { - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode434(x64Operand &operand) @@ -43306,17 +43347,17 @@ asmError x64Parser::Opcode434(x64Operand &operand) operand.values[19] = OpcodeCodings434_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings435_23[] = { - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings435_19[] = { - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode435(x64Operand &operand) @@ -43330,12 +43371,12 @@ asmError x64Parser::Opcode435(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings436_23[] = { - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings436_19[] = { - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode436(x64Operand &operand) @@ -43344,16 +43385,17 @@ asmError x64Parser::Opcode436(x64Operand &operand) operand.values[19] = OpcodeCodings436_19; asmError rv; { - rv = Opcode24(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings437_23[] = { + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings437_19[] = { - { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode437(x64Operand &operand) @@ -43362,17 +43404,17 @@ asmError x64Parser::Opcode437(x64Operand &operand) operand.values[19] = OpcodeCodings437_19; asmError rv; { - rv = Opcode24(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings438_23[] = { - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings438_19[] = { - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode438(x64Operand &operand) @@ -43381,7 +43423,7 @@ asmError x64Parser::Opcode438(x64Operand &operand) operand.values[19] = OpcodeCodings438_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode24(operand); } return rv; } @@ -43389,8 +43431,8 @@ Coding x64Parser::OpcodeCodings439_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings439_19[] = { - { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode439(x64Operand &operand) @@ -43399,16 +43441,17 @@ asmError x64Parser::Opcode439(x64Operand &operand) operand.values[19] = OpcodeCodings439_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode24(operand); } return rv; } Coding x64Parser::OpcodeCodings440_23[] = { + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings440_19[] = { - { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode440(x64Operand &operand) @@ -43417,17 +43460,16 @@ asmError x64Parser::Opcode440(x64Operand &operand) operand.values[19] = OpcodeCodings440_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings441_23[] = { - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings441_19[] = { - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode441(x64Operand &operand) @@ -43436,17 +43478,16 @@ asmError x64Parser::Opcode441(x64Operand &operand) operand.values[19] = OpcodeCodings441_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings442_23[] = { - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings442_19[] = { - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode442(x64Operand &operand) @@ -43455,17 +43496,17 @@ asmError x64Parser::Opcode442(x64Operand &operand) operand.values[19] = OpcodeCodings442_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings443_23[] = { - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings443_19[] = { - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode443(x64Operand &operand) @@ -43474,17 +43515,17 @@ asmError x64Parser::Opcode443(x64Operand &operand) operand.values[19] = OpcodeCodings443_19; asmError rv; { - rv = Opcode26(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings444_23[] = { - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings444_19[] = { - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode444(x64Operand &operand) @@ -43493,17 +43534,17 @@ asmError x64Parser::Opcode444(x64Operand &operand) operand.values[19] = OpcodeCodings444_19; asmError rv; { - rv = Opcode26(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings445_23[] = { - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings445_19[] = { - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode445(x64Operand &operand) @@ -43512,17 +43553,17 @@ asmError x64Parser::Opcode445(x64Operand &operand) operand.values[19] = OpcodeCodings445_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode26(operand); } return rv; } Coding x64Parser::OpcodeCodings446_23[] = { - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings446_19[] = { - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode446(x64Operand &operand) @@ -43531,17 +43572,17 @@ asmError x64Parser::Opcode446(x64Operand &operand) operand.values[19] = OpcodeCodings446_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode26(operand); } return rv; } Coding x64Parser::OpcodeCodings447_23[] = { - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings447_19[] = { - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode447(x64Operand &operand) @@ -43555,12 +43596,12 @@ asmError x64Parser::Opcode447(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings448_23[] = { - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings448_19[] = { - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode448(x64Operand &operand) @@ -43569,17 +43610,17 @@ asmError x64Parser::Opcode448(x64Operand &operand) operand.values[19] = OpcodeCodings448_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings449_23[] = { - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings449_19[] = { - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode449(x64Operand &operand) @@ -43593,11 +43634,12 @@ asmError x64Parser::Opcode449(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings450_23[] = { + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings450_19[] = { - { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode450(x64Operand &operand) @@ -43611,12 +43653,12 @@ asmError x64Parser::Opcode450(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings451_23[] = { - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings451_19[] = { - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode451(x64Operand &operand) @@ -43625,17 +43667,16 @@ asmError x64Parser::Opcode451(x64Operand &operand) operand.values[19] = OpcodeCodings451_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings452_23[] = { - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings452_19[] = { - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode452(x64Operand &operand) @@ -43644,17 +43685,17 @@ asmError x64Parser::Opcode452(x64Operand &operand) operand.values[19] = OpcodeCodings452_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings453_23[] = { - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings453_19[] = { - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode453(x64Operand &operand) @@ -43663,16 +43704,17 @@ asmError x64Parser::Opcode453(x64Operand &operand) operand.values[19] = OpcodeCodings453_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings454_23[] = { + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings454_19[] = { - { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode454(x64Operand &operand) @@ -43681,17 +43723,17 @@ asmError x64Parser::Opcode454(x64Operand &operand) operand.values[19] = OpcodeCodings454_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings455_23[] = { - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings455_19[] = { - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode455(x64Operand &operand) @@ -43705,12 +43747,11 @@ asmError x64Parser::Opcode455(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings456_23[] = { - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings456_19[] = { - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode456(x64Operand &operand) @@ -43724,13 +43765,12 @@ asmError x64Parser::Opcode456(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings457_23[] = { - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings457_19[] = { - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode457(x64Operand &operand) @@ -43739,17 +43779,17 @@ asmError x64Parser::Opcode457(x64Operand &operand) operand.values[19] = OpcodeCodings457_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings458_23[] = { + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings458_19[] = { - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode458(x64Operand &operand) @@ -43758,17 +43798,18 @@ asmError x64Parser::Opcode458(x64Operand &operand) operand.values[19] = OpcodeCodings458_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings459_23[] = { - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings459_19[] = { - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode459(x64Operand &operand) @@ -43777,17 +43818,17 @@ asmError x64Parser::Opcode459(x64Operand &operand) operand.values[19] = OpcodeCodings459_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings460_23[] = { - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings460_19[] = { - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode460(x64Operand &operand) @@ -43796,18 +43837,17 @@ asmError x64Parser::Opcode460(x64Operand &operand) operand.values[19] = OpcodeCodings460_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings461_23[] = { - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings461_19[] = { - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode461(x64Operand &operand) @@ -43816,17 +43856,17 @@ asmError x64Parser::Opcode461(x64Operand &operand) operand.values[19] = OpcodeCodings461_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings462_23[] = { - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings462_19[] = { - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode462(x64Operand &operand) @@ -43839,1176 +43879,1187 @@ asmError x64Parser::Opcode462(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings463_23[] = { + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings463_19[] = { + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode463(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8466, operand); + operand.values[23] = OpcodeCodings463_23; + operand.values[19] = OpcodeCodings463_19; + asmError rv; + { + rv = Opcode30(operand); + } return rv; } +Coding x64Parser::OpcodeCodings464_23[] = { + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings464_19[] = { + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode464(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8470, operand); + operand.values[23] = OpcodeCodings464_23; + operand.values[19] = OpcodeCodings464_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; +} +asmError x64Parser::Opcode465(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches8472, operand); + return rv; +} +asmError x64Parser::Opcode466(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches8476, operand); return rv; } -Coding x64Parser::OpcodeCodings465_23[] = { +Coding x64Parser::OpcodeCodings467_23[] = { { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings465_19[] = { +Coding x64Parser::OpcodeCodings467_19[] = { { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode465(x64Operand &operand) +asmError x64Parser::Opcode467(x64Operand &operand) { - operand.values[23] = OpcodeCodings465_23; - operand.values[19] = OpcodeCodings465_19; + operand.values[23] = OpcodeCodings467_23; + operand.values[19] = OpcodeCodings467_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings466_23[] = { +Coding x64Parser::OpcodeCodings468_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings466_19[] = { +Coding x64Parser::OpcodeCodings468_19[] = { { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode466(x64Operand &operand) +asmError x64Parser::Opcode468(x64Operand &operand) { - operand.values[23] = OpcodeCodings466_23; - operand.values[19] = OpcodeCodings466_19; + operand.values[23] = OpcodeCodings468_23; + operand.values[19] = OpcodeCodings468_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings467_23[] = { +Coding x64Parser::OpcodeCodings469_23[] = { { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings467_19[] = { +Coding x64Parser::OpcodeCodings469_19[] = { { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode467(x64Operand &operand) +asmError x64Parser::Opcode469(x64Operand &operand) { - operand.values[23] = OpcodeCodings467_23; - operand.values[19] = OpcodeCodings467_19; + operand.values[23] = OpcodeCodings469_23; + operand.values[19] = OpcodeCodings469_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings468_23[] = { +Coding x64Parser::OpcodeCodings470_23[] = { { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings468_19[] = { +Coding x64Parser::OpcodeCodings470_19[] = { { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode468(x64Operand &operand) +asmError x64Parser::Opcode470(x64Operand &operand) { - operand.values[23] = OpcodeCodings468_23; - operand.values[19] = OpcodeCodings468_19; + operand.values[23] = OpcodeCodings470_23; + operand.values[19] = OpcodeCodings470_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings469_19[] = { +Coding x64Parser::OpcodeCodings471_19[] = { { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode469(x64Operand &operand) +asmError x64Parser::Opcode471(x64Operand &operand) { - operand.values[19] = OpcodeCodings469_19; + operand.values[19] = OpcodeCodings471_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings470_19[] = { +Coding x64Parser::OpcodeCodings472_19[] = { { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode470(x64Operand &operand) +asmError x64Parser::Opcode472(x64Operand &operand) { - operand.values[19] = OpcodeCodings470_19; + operand.values[19] = OpcodeCodings472_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings471_23[] = { +Coding x64Parser::OpcodeCodings473_23[] = { { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings471_19[] = { +Coding x64Parser::OpcodeCodings473_19[] = { { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode471(x64Operand &operand) +asmError x64Parser::Opcode473(x64Operand &operand) { - operand.values[23] = OpcodeCodings471_23; - operand.values[19] = OpcodeCodings471_19; + operand.values[23] = OpcodeCodings473_23; + operand.values[19] = OpcodeCodings473_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings472_23[] = { +Coding x64Parser::OpcodeCodings474_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings472_19[] = { +Coding x64Parser::OpcodeCodings474_19[] = { { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode472(x64Operand &operand) +asmError x64Parser::Opcode474(x64Operand &operand) { - operand.values[23] = OpcodeCodings472_23; - operand.values[19] = OpcodeCodings472_19; + operand.values[23] = OpcodeCodings474_23; + operand.values[19] = OpcodeCodings474_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings473_23[] = { +Coding x64Parser::OpcodeCodings475_23[] = { { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings473_19[] = { +Coding x64Parser::OpcodeCodings475_19[] = { { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode473(x64Operand &operand) +asmError x64Parser::Opcode475(x64Operand &operand) { - operand.values[23] = OpcodeCodings473_23; - operand.values[19] = OpcodeCodings473_19; + operand.values[23] = OpcodeCodings475_23; + operand.values[19] = OpcodeCodings475_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings474_23[] = { +Coding x64Parser::OpcodeCodings476_23[] = { { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings474_19[] = { +Coding x64Parser::OpcodeCodings476_19[] = { { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode474(x64Operand &operand) +asmError x64Parser::Opcode476(x64Operand &operand) { - operand.values[23] = OpcodeCodings474_23; - operand.values[19] = OpcodeCodings474_19; + operand.values[23] = OpcodeCodings476_23; + operand.values[19] = OpcodeCodings476_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings475_19[] = { +Coding x64Parser::OpcodeCodings477_19[] = { { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode475(x64Operand &operand) +asmError x64Parser::Opcode477(x64Operand &operand) { - operand.values[19] = OpcodeCodings475_19; + operand.values[19] = OpcodeCodings477_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings476_23[] = { +Coding x64Parser::OpcodeCodings478_23[] = { { CODING_NAME("movapd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings476_36[] = { +Coding x64Parser::OpcodeCodings478_36[] = { { CODING_NAME("movapd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode476(x64Operand &operand) +asmError x64Parser::Opcode478(x64Operand &operand) { - operand.values[23] = OpcodeCodings476_23; - operand.values[36] = OpcodeCodings476_36; + operand.values[23] = OpcodeCodings478_23; + operand.values[36] = OpcodeCodings478_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings477_23[] = { +Coding x64Parser::OpcodeCodings479_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings477_36[] = { +Coding x64Parser::OpcodeCodings479_36[] = { { CODING_NAME("movaps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode477(x64Operand &operand) +asmError x64Parser::Opcode479(x64Operand &operand) { - operand.values[23] = OpcodeCodings477_23; - operand.values[36] = OpcodeCodings477_36; + operand.values[23] = OpcodeCodings479_23; + operand.values[36] = OpcodeCodings479_36; asmError rv; { rv = Opcode20(operand); } return rv; } -asmError x64Parser::Opcode478(x64Operand &operand) +asmError x64Parser::Opcode480(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8487, operand); + asmError rv = ParseOperands(tokenBranches8493, operand); return rv; } -asmError x64Parser::Opcode479(x64Operand &operand) +asmError x64Parser::Opcode481(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8500, operand); + asmError rv = ParseOperands(tokenBranches8506, operand); return rv; } -Coding x64Parser::OpcodeCodings480_23[] = { +Coding x64Parser::OpcodeCodings482_23[] = { { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings480_19[] = { +Coding x64Parser::OpcodeCodings482_19[] = { { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode480(x64Operand &operand) +asmError x64Parser::Opcode482(x64Operand &operand) { - operand.values[23] = OpcodeCodings480_23; - operand.values[19] = OpcodeCodings480_19; + operand.values[23] = OpcodeCodings482_23; + operand.values[19] = OpcodeCodings482_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings481_23[] = { +Coding x64Parser::OpcodeCodings483_23[] = { { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings481_19[] = { +Coding x64Parser::OpcodeCodings483_19[] = { { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode481(x64Operand &operand) +asmError x64Parser::Opcode483(x64Operand &operand) { - operand.values[23] = OpcodeCodings481_23; - operand.values[19] = OpcodeCodings481_19; + operand.values[23] = OpcodeCodings483_23; + operand.values[19] = OpcodeCodings483_19; asmError rv; { rv = Opcode23(operand); } return rv; } -Coding x64Parser::OpcodeCodings482_23[] = { +Coding x64Parser::OpcodeCodings484_23[] = { { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings482_36[] = { +Coding x64Parser::OpcodeCodings484_36[] = { { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode482(x64Operand &operand) +asmError x64Parser::Opcode484(x64Operand &operand) { - operand.values[23] = OpcodeCodings482_23; - operand.values[36] = OpcodeCodings482_36; + operand.values[23] = OpcodeCodings484_23; + operand.values[36] = OpcodeCodings484_36; asmError rv; { rv = Opcode21(operand); } return rv; } -Coding x64Parser::OpcodeCodings483_23[] = { +Coding x64Parser::OpcodeCodings485_23[] = { { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings483_36[] = { +Coding x64Parser::OpcodeCodings485_36[] = { { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode483(x64Operand &operand) +asmError x64Parser::Opcode485(x64Operand &operand) { - operand.values[23] = OpcodeCodings483_23; - operand.values[36] = OpcodeCodings483_36; + operand.values[23] = OpcodeCodings485_23; + operand.values[36] = OpcodeCodings485_36; asmError rv; { rv = Opcode21(operand); } return rv; } -asmError x64Parser::Opcode484(x64Operand &operand) +asmError x64Parser::Opcode486(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8529, operand); + asmError rv = ParseOperands(tokenBranches8535, operand); return rv; } -Coding x64Parser::OpcodeCodings485_23[] = { +Coding x64Parser::OpcodeCodings487_23[] = { { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings485_36[] = { +Coding x64Parser::OpcodeCodings487_36[] = { { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode485(x64Operand &operand) +asmError x64Parser::Opcode487(x64Operand &operand) { - operand.values[23] = OpcodeCodings485_23; - operand.values[36] = OpcodeCodings485_36; + operand.values[23] = OpcodeCodings487_23; + operand.values[36] = OpcodeCodings487_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings486_23[] = { +Coding x64Parser::OpcodeCodings488_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings486_36[] = { +Coding x64Parser::OpcodeCodings488_36[] = { { CODING_NAME("movhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode486(x64Operand &operand) +asmError x64Parser::Opcode488(x64Operand &operand) { - operand.values[23] = OpcodeCodings486_23; - operand.values[36] = OpcodeCodings486_36; + operand.values[23] = OpcodeCodings488_23; + operand.values[36] = OpcodeCodings488_36; asmError rv; { rv = Opcode22(operand); } return rv; } -asmError x64Parser::Opcode487(x64Operand &operand) +asmError x64Parser::Opcode489(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8535, operand); + asmError rv = ParseOperands(tokenBranches8541, operand); return rv; } -Coding x64Parser::OpcodeCodings488_23[] = { +Coding x64Parser::OpcodeCodings490_23[] = { { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings488_36[] = { +Coding x64Parser::OpcodeCodings490_36[] = { { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode488(x64Operand &operand) +asmError x64Parser::Opcode490(x64Operand &operand) { - operand.values[23] = OpcodeCodings488_23; - operand.values[36] = OpcodeCodings488_36; + operand.values[23] = OpcodeCodings490_23; + operand.values[36] = OpcodeCodings490_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings489_23[] = { +Coding x64Parser::OpcodeCodings491_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings489_36[] = { +Coding x64Parser::OpcodeCodings491_36[] = { { CODING_NAME("movlps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode489(x64Operand &operand) +asmError x64Parser::Opcode491(x64Operand &operand) { - operand.values[23] = OpcodeCodings489_23; - operand.values[36] = OpcodeCodings489_36; + operand.values[23] = OpcodeCodings491_23; + operand.values[36] = OpcodeCodings491_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings490_23[] = { +Coding x64Parser::OpcodeCodings492_23[] = { { CODING_NAME("movmskpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings490_19[] = { +Coding x64Parser::OpcodeCodings492_19[] = { { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode490(x64Operand &operand) +asmError x64Parser::Opcode492(x64Operand &operand) { - operand.values[23] = OpcodeCodings490_23; - operand.values[19] = OpcodeCodings490_19; + operand.values[23] = OpcodeCodings492_23; + operand.values[19] = OpcodeCodings492_19; asmError rv; { rv = Opcode25(operand); } return rv; } -Coding x64Parser::OpcodeCodings491_23[] = { +Coding x64Parser::OpcodeCodings493_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings491_19[] = { +Coding x64Parser::OpcodeCodings493_19[] = { { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode491(x64Operand &operand) +asmError x64Parser::Opcode493(x64Operand &operand) { - operand.values[23] = OpcodeCodings491_23; - operand.values[19] = OpcodeCodings491_19; + operand.values[23] = OpcodeCodings493_23; + operand.values[19] = OpcodeCodings493_19; asmError rv; { rv = Opcode25(operand); } return rv; } -asmError x64Parser::Opcode492(x64Operand &operand) +asmError x64Parser::Opcode494(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8543, operand); + asmError rv = ParseOperands(tokenBranches8549, operand); return rv; } -Coding x64Parser::OpcodeCodings493_19[] = { +Coding x64Parser::OpcodeCodings495_19[] = { { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode493(x64Operand &operand) +asmError x64Parser::Opcode495(x64Operand &operand) { - operand.values[19] = OpcodeCodings493_19; - asmError rv = ParseOperands(tokenBranches8547, operand); + operand.values[19] = OpcodeCodings495_19; + asmError rv = ParseOperands(tokenBranches8553, operand); return rv; } -asmError x64Parser::Opcode494(x64Operand &operand) +asmError x64Parser::Opcode496(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8554, operand); + asmError rv = ParseOperands(tokenBranches8560, operand); return rv; } -asmError x64Parser::Opcode495(x64Operand &operand) +asmError x64Parser::Opcode497(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8558, operand); + asmError rv = ParseOperands(tokenBranches8564, operand); return rv; } -asmError x64Parser::Opcode496(x64Operand &operand) +asmError x64Parser::Opcode498(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8562, operand); + asmError rv = ParseOperands(tokenBranches8568, operand); return rv; } -asmError x64Parser::Opcode497(x64Operand &operand) +asmError x64Parser::Opcode499(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8566, operand); + asmError rv = ParseOperands(tokenBranches8572, operand); return rv; } -Coding x64Parser::OpcodeCodings498_23[] = { +Coding x64Parser::OpcodeCodings500_23[] = { { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings498_19[] = { +Coding x64Parser::OpcodeCodings500_19[] = { { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode498(x64Operand &operand) +asmError x64Parser::Opcode500(x64Operand &operand) { - operand.values[23] = OpcodeCodings498_23; - operand.values[19] = OpcodeCodings498_19; + operand.values[23] = OpcodeCodings500_23; + operand.values[19] = OpcodeCodings500_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings499_23[] = { +Coding x64Parser::OpcodeCodings501_23[] = { { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings499_19[] = { +Coding x64Parser::OpcodeCodings501_19[] = { { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode499(x64Operand &operand) +asmError x64Parser::Opcode501(x64Operand &operand) { - operand.values[23] = OpcodeCodings499_23; - operand.values[19] = OpcodeCodings499_19; + operand.values[23] = OpcodeCodings501_23; + operand.values[19] = OpcodeCodings501_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings500_23[] = { +Coding x64Parser::OpcodeCodings502_23[] = { { CODING_NAME("movss") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings500_36[] = { +Coding x64Parser::OpcodeCodings502_36[] = { { CODING_NAME("movss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode500(x64Operand &operand) +asmError x64Parser::Opcode502(x64Operand &operand) { - operand.values[23] = OpcodeCodings500_23; - operand.values[36] = OpcodeCodings500_36; + operand.values[23] = OpcodeCodings502_23; + operand.values[36] = OpcodeCodings502_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings501_23[] = { +Coding x64Parser::OpcodeCodings503_23[] = { { CODING_NAME("movupd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings501_36[] = { +Coding x64Parser::OpcodeCodings503_36[] = { { CODING_NAME("movupd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode501(x64Operand &operand) +asmError x64Parser::Opcode503(x64Operand &operand) { - operand.values[23] = OpcodeCodings501_23; - operand.values[36] = OpcodeCodings501_36; + operand.values[23] = OpcodeCodings503_23; + operand.values[36] = OpcodeCodings503_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings502_23[] = { +Coding x64Parser::OpcodeCodings504_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings502_36[] = { +Coding x64Parser::OpcodeCodings504_36[] = { { CODING_NAME("movups") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode502(x64Operand &operand) +asmError x64Parser::Opcode504(x64Operand &operand) { - operand.values[23] = OpcodeCodings502_23; - operand.values[36] = OpcodeCodings502_36; + operand.values[23] = OpcodeCodings504_23; + operand.values[36] = OpcodeCodings504_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings503_23[] = { +Coding x64Parser::OpcodeCodings505_23[] = { { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings503_19[] = { +Coding x64Parser::OpcodeCodings505_19[] = { { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode503(x64Operand &operand) +asmError x64Parser::Opcode505(x64Operand &operand) { - operand.values[23] = OpcodeCodings503_23; - operand.values[19] = OpcodeCodings503_19; + operand.values[23] = OpcodeCodings505_23; + operand.values[19] = OpcodeCodings505_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings504_23[] = { +Coding x64Parser::OpcodeCodings506_23[] = { { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings504_19[] = { +Coding x64Parser::OpcodeCodings506_19[] = { { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode504(x64Operand &operand) +asmError x64Parser::Opcode506(x64Operand &operand) { - operand.values[23] = OpcodeCodings504_23; - operand.values[19] = OpcodeCodings504_19; + operand.values[23] = OpcodeCodings506_23; + operand.values[19] = OpcodeCodings506_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings505_23[] = { +Coding x64Parser::OpcodeCodings507_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings505_19[] = { +Coding x64Parser::OpcodeCodings507_19[] = { { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode505(x64Operand &operand) +asmError x64Parser::Opcode507(x64Operand &operand) { - operand.values[23] = OpcodeCodings505_23; - operand.values[19] = OpcodeCodings505_19; + operand.values[23] = OpcodeCodings507_23; + operand.values[19] = OpcodeCodings507_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings506_23[] = { +Coding x64Parser::OpcodeCodings508_23[] = { { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings506_19[] = { +Coding x64Parser::OpcodeCodings508_19[] = { { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode506(x64Operand &operand) +asmError x64Parser::Opcode508(x64Operand &operand) { - operand.values[23] = OpcodeCodings506_23; - operand.values[19] = OpcodeCodings506_19; + operand.values[23] = OpcodeCodings508_23; + operand.values[19] = OpcodeCodings508_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings507_23[] = { +Coding x64Parser::OpcodeCodings509_23[] = { { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings507_19[] = { +Coding x64Parser::OpcodeCodings509_19[] = { { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode507(x64Operand &operand) +asmError x64Parser::Opcode509(x64Operand &operand) { - operand.values[23] = OpcodeCodings507_23; - operand.values[19] = OpcodeCodings507_19; + operand.values[23] = OpcodeCodings509_23; + operand.values[19] = OpcodeCodings509_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings508_23[] = { +Coding x64Parser::OpcodeCodings510_23[] = { { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings508_19[] = { +Coding x64Parser::OpcodeCodings510_19[] = { { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode508(x64Operand &operand) +asmError x64Parser::Opcode510(x64Operand &operand) { - operand.values[23] = OpcodeCodings508_23; - operand.values[19] = OpcodeCodings508_19; + operand.values[23] = OpcodeCodings510_23; + operand.values[19] = OpcodeCodings510_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings509_23[] = { +Coding x64Parser::OpcodeCodings511_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings509_19[] = { +Coding x64Parser::OpcodeCodings511_19[] = { { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode509(x64Operand &operand) +asmError x64Parser::Opcode511(x64Operand &operand) { - operand.values[23] = OpcodeCodings509_23; - operand.values[19] = OpcodeCodings509_19; + operand.values[23] = OpcodeCodings511_23; + operand.values[19] = OpcodeCodings511_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings510_19[] = { +Coding x64Parser::OpcodeCodings512_19[] = { { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode510(x64Operand &operand) +asmError x64Parser::Opcode512(x64Operand &operand) { - operand.values[19] = OpcodeCodings510_19; + operand.values[19] = OpcodeCodings512_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings511_19[] = { +Coding x64Parser::OpcodeCodings513_19[] = { { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode511(x64Operand &operand) +asmError x64Parser::Opcode513(x64Operand &operand) { - operand.values[19] = OpcodeCodings511_19; + operand.values[19] = OpcodeCodings513_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings512_23[] = { +Coding x64Parser::OpcodeCodings514_23[] = { { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings512_19[] = { +Coding x64Parser::OpcodeCodings514_19[] = { { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode512(x64Operand &operand) +asmError x64Parser::Opcode514(x64Operand &operand) { - operand.values[23] = OpcodeCodings512_23; - operand.values[19] = OpcodeCodings512_19; + operand.values[23] = OpcodeCodings514_23; + operand.values[19] = OpcodeCodings514_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings513_19[] = { +Coding x64Parser::OpcodeCodings515_19[] = { { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode513(x64Operand &operand) +asmError x64Parser::Opcode515(x64Operand &operand) { - operand.values[19] = OpcodeCodings513_19; + operand.values[19] = OpcodeCodings515_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings514_19[] = { +Coding x64Parser::OpcodeCodings516_19[] = { { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode514(x64Operand &operand) +asmError x64Parser::Opcode516(x64Operand &operand) { - operand.values[19] = OpcodeCodings514_19; + operand.values[19] = OpcodeCodings516_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings515_19[] = { +Coding x64Parser::OpcodeCodings517_19[] = { { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode515(x64Operand &operand) +asmError x64Parser::Opcode517(x64Operand &operand) { - operand.values[19] = OpcodeCodings515_19; + operand.values[19] = OpcodeCodings517_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings516_19[] = { +Coding x64Parser::OpcodeCodings518_19[] = { { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode516(x64Operand &operand) +asmError x64Parser::Opcode518(x64Operand &operand) { - operand.values[19] = OpcodeCodings516_19; + operand.values[19] = OpcodeCodings518_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings517_19[] = { +Coding x64Parser::OpcodeCodings519_19[] = { { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode517(x64Operand &operand) +asmError x64Parser::Opcode519(x64Operand &operand) { - operand.values[19] = OpcodeCodings517_19; + operand.values[19] = OpcodeCodings519_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings518_19[] = { +Coding x64Parser::OpcodeCodings520_19[] = { { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode518(x64Operand &operand) +asmError x64Parser::Opcode520(x64Operand &operand) { - operand.values[19] = OpcodeCodings518_19; + operand.values[19] = OpcodeCodings520_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings519_19[] = { +Coding x64Parser::OpcodeCodings521_19[] = { { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode519(x64Operand &operand) +asmError x64Parser::Opcode521(x64Operand &operand) { - operand.values[19] = OpcodeCodings519_19; + operand.values[19] = OpcodeCodings521_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings520_19[] = { +Coding x64Parser::OpcodeCodings522_19[] = { { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode520(x64Operand &operand) +asmError x64Parser::Opcode522(x64Operand &operand) { - operand.values[19] = OpcodeCodings520_19; - asmError rv = ParseOperands(tokenBranches8592, operand); + operand.values[19] = OpcodeCodings522_19; + asmError rv = ParseOperands(tokenBranches8598, operand); return rv; } -Coding x64Parser::OpcodeCodings521_19[] = { +Coding x64Parser::OpcodeCodings523_19[] = { { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode521(x64Operand &operand) +asmError x64Parser::Opcode523(x64Operand &operand) { - operand.values[19] = OpcodeCodings521_19; + operand.values[19] = OpcodeCodings523_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings522_19[] = { +Coding x64Parser::OpcodeCodings524_19[] = { { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode522(x64Operand &operand) +asmError x64Parser::Opcode524(x64Operand &operand) { - operand.values[19] = OpcodeCodings522_19; + operand.values[19] = OpcodeCodings524_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings523_19[] = { +Coding x64Parser::OpcodeCodings525_19[] = { { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode523(x64Operand &operand) +asmError x64Parser::Opcode525(x64Operand &operand) { - operand.values[19] = OpcodeCodings523_19; + operand.values[19] = OpcodeCodings525_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings524_19[] = { +Coding x64Parser::OpcodeCodings526_19[] = { { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode524(x64Operand &operand) +asmError x64Parser::Opcode526(x64Operand &operand) { - operand.values[19] = OpcodeCodings524_19; + operand.values[19] = OpcodeCodings526_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings525_23[] = { +Coding x64Parser::OpcodeCodings527_23[] = { { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings525_19[] = { +Coding x64Parser::OpcodeCodings527_19[] = { { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode525(x64Operand &operand) +asmError x64Parser::Opcode527(x64Operand &operand) { - operand.values[23] = OpcodeCodings525_23; - operand.values[19] = OpcodeCodings525_19; + operand.values[23] = OpcodeCodings527_23; + operand.values[19] = OpcodeCodings527_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings526_19[] = { +Coding x64Parser::OpcodeCodings528_19[] = { { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode526(x64Operand &operand) +asmError x64Parser::Opcode528(x64Operand &operand) { - operand.values[19] = OpcodeCodings526_19; + operand.values[19] = OpcodeCodings528_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings527_19[] = { +Coding x64Parser::OpcodeCodings529_19[] = { { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode527(x64Operand &operand) +asmError x64Parser::Opcode529(x64Operand &operand) { - operand.values[19] = OpcodeCodings527_19; + operand.values[19] = OpcodeCodings529_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings528_19[] = { +Coding x64Parser::OpcodeCodings530_19[] = { { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode528(x64Operand &operand) +asmError x64Parser::Opcode530(x64Operand &operand) { - operand.values[19] = OpcodeCodings528_19; + operand.values[19] = OpcodeCodings530_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings529_23[] = { +Coding x64Parser::OpcodeCodings531_23[] = { { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings529_19[] = { +Coding x64Parser::OpcodeCodings531_19[] = { { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode529(x64Operand &operand) +asmError x64Parser::Opcode531(x64Operand &operand) { - operand.values[23] = OpcodeCodings529_23; - operand.values[19] = OpcodeCodings529_19; + operand.values[23] = OpcodeCodings531_23; + operand.values[19] = OpcodeCodings531_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings530_23[] = { +Coding x64Parser::OpcodeCodings532_23[] = { { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings530_19[] = { +Coding x64Parser::OpcodeCodings532_19[] = { { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode530(x64Operand &operand) +asmError x64Parser::Opcode532(x64Operand &operand) { - operand.values[23] = OpcodeCodings530_23; - operand.values[19] = OpcodeCodings530_19; + operand.values[23] = OpcodeCodings532_23; + operand.values[19] = OpcodeCodings532_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings531_19[] = { +Coding x64Parser::OpcodeCodings533_19[] = { { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode531(x64Operand &operand) +asmError x64Parser::Opcode533(x64Operand &operand) { - operand.values[19] = OpcodeCodings531_19; + operand.values[19] = OpcodeCodings533_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings532_19[] = { +Coding x64Parser::OpcodeCodings534_19[] = { { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode532(x64Operand &operand) +asmError x64Parser::Opcode534(x64Operand &operand) { - operand.values[19] = OpcodeCodings532_19; + operand.values[19] = OpcodeCodings534_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings533_19[] = { +Coding x64Parser::OpcodeCodings535_19[] = { { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode533(x64Operand &operand) +asmError x64Parser::Opcode535(x64Operand &operand) { - operand.values[19] = OpcodeCodings533_19; + operand.values[19] = OpcodeCodings535_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings534_19[] = { +Coding x64Parser::OpcodeCodings536_19[] = { { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode534(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings534_19; - asmError rv = ParseOperands(tokenBranches8616, operand); - return rv; -} -Coding x64Parser::OpcodeCodings535_19[] = { - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode535(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings535_19; - asmError rv = ParseOperands(tokenBranches8622, operand); - return rv; -} -Coding x64Parser::OpcodeCodings536_19[] = { - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode536(x64Operand &operand) { operand.values[19] = OpcodeCodings536_19; - asmError rv = ParseOperands(tokenBranches8628, operand); + asmError rv = ParseOperands(tokenBranches8622, operand); return rv; } +Coding x64Parser::OpcodeCodings537_19[] = { + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode537(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8634, operand); + operand.values[19] = OpcodeCodings537_19; + asmError rv = ParseOperands(tokenBranches8628, operand); return rv; } Coding x64Parser::OpcodeCodings538_19[] = { - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode538(x64Operand &operand) { operand.values[19] = OpcodeCodings538_19; - asmError rv = ParseOperands(tokenBranches8655, operand); + asmError rv = ParseOperands(tokenBranches8634, operand); return rv; } -Coding x64Parser::OpcodeCodings539_19[] = { - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode539(x64Operand &operand) { - operand.values[19] = OpcodeCodings539_19; - asmError rv = ParseOperands(tokenBranches8661, operand); + asmError rv = ParseOperands(tokenBranches8640, operand); return rv; } Coding x64Parser::OpcodeCodings540_19[] = { - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode540(x64Operand &operand) { operand.values[19] = OpcodeCodings540_19; - asmError rv = ParseOperands(tokenBranches8667, operand); + asmError rv = ParseOperands(tokenBranches8661, operand); return rv; } +Coding x64Parser::OpcodeCodings541_19[] = { + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode541(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8673, operand); + operand.values[19] = OpcodeCodings541_19; + asmError rv = ParseOperands(tokenBranches8667, operand); return rv; } Coding x64Parser::OpcodeCodings542_19[] = { - { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode542(x64Operand &operand) { operand.values[19] = OpcodeCodings542_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8673, operand); return rv; } -Coding x64Parser::OpcodeCodings543_19[] = { - { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode543(x64Operand &operand) { - operand.values[19] = OpcodeCodings543_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8679, operand); return rv; } Coding x64Parser::OpcodeCodings544_19[] = { - { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode544(x64Operand &operand) @@ -45021,8 +45072,8 @@ asmError x64Parser::Opcode544(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings545_19[] = { - { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode545(x64Operand &operand) @@ -45035,8 +45086,8 @@ asmError x64Parser::Opcode545(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings546_19[] = { - { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode546(x64Operand &operand) @@ -45049,19 +45100,22 @@ asmError x64Parser::Opcode546(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings547_19[] = { - { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode547(x64Operand &operand) { operand.values[19] = OpcodeCodings547_19; - asmError rv = ParseOperands(tokenBranches8699, operand); + asmError rv; + { + rv = Opcode27(operand); + } return rv; } Coding x64Parser::OpcodeCodings548_19[] = { - { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode548(x64Operand &operand) @@ -45074,22 +45128,19 @@ asmError x64Parser::Opcode548(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings549_19[] = { - { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode549(x64Operand &operand) { operand.values[19] = OpcodeCodings549_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8705, operand); return rv; } Coding x64Parser::OpcodeCodings550_19[] = { - { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode550(x64Operand &operand) @@ -45102,8 +45153,8 @@ asmError x64Parser::Opcode550(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings551_19[] = { - { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode551(x64Operand &operand) @@ -45116,8 +45167,8 @@ asmError x64Parser::Opcode551(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings552_19[] = { - { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode552(x64Operand &operand) @@ -45129,51 +45180,41 @@ asmError x64Parser::Opcode552(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings553_23[] = { - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings553_19[] = { - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode553(x64Operand &operand) { - operand.values[23] = OpcodeCodings553_23; operand.values[19] = OpcodeCodings553_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings554_23[] = { - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings554_19[] = { - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode554(x64Operand &operand) { - operand.values[23] = OpcodeCodings554_23; operand.values[19] = OpcodeCodings554_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings555_23[] = { - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings555_19[] = { - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode555(x64Operand &operand) @@ -45187,69 +45228,68 @@ asmError x64Parser::Opcode555(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings556_23[] = { + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings556_19[] = { - { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode556(x64Operand &operand) { operand.values[23] = OpcodeCodings556_23; operand.values[19] = OpcodeCodings556_19; - asmError rv = ParseOperands(tokenBranches8720, operand); + asmError rv; + { + rv = Opcode28(operand); + } return rv; } -Coding x64Parser::OpcodeCodings557_39[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings557_36[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings557_23[] = { + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings557_37[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings557_19[] = { + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode557(x64Operand &operand) { - operand.values[39] = OpcodeCodings557_39; - operand.values[36] = OpcodeCodings557_36; - operand.values[37] = OpcodeCodings557_37; + operand.values[23] = OpcodeCodings557_23; + operand.values[19] = OpcodeCodings557_19; asmError rv; { - rv = Opcode29(operand); + rv = Opcode28(operand); } return rv; } Coding x64Parser::OpcodeCodings558_23[] = { - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings558_19[] = { - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode558(x64Operand &operand) { operand.values[23] = OpcodeCodings558_23; operand.values[19] = OpcodeCodings558_19; - asmError rv = ParseOperands(tokenBranches8727, operand); + asmError rv = ParseOperands(tokenBranches8726, operand); return rv; } Coding x64Parser::OpcodeCodings559_39[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_36[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_37[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode559(x64Operand &operand) @@ -45263,39 +45303,32 @@ asmError x64Parser::Opcode559(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings560_39[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings560_36[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings560_23[] = { + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings560_37[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings560_19[] = { + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode560(x64Operand &operand) { - operand.values[39] = OpcodeCodings560_39; - operand.values[36] = OpcodeCodings560_36; - operand.values[37] = OpcodeCodings560_37; - asmError rv; - { - rv = Opcode29(operand); - } + operand.values[23] = OpcodeCodings560_23; + operand.values[19] = OpcodeCodings560_19; + asmError rv = ParseOperands(tokenBranches8733, operand); return rv; } Coding x64Parser::OpcodeCodings561_39[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_36[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_37[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode561(x64Operand &operand) @@ -45310,15 +45343,15 @@ asmError x64Parser::Opcode561(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings562_39[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_36[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_37[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode562(x64Operand &operand) @@ -45333,15 +45366,15 @@ asmError x64Parser::Opcode562(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings563_39[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_36[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_37[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode563(x64Operand &operand) @@ -45355,32 +45388,39 @@ asmError x64Parser::Opcode563(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings564_23[] = { - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings564_39[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings564_19[] = { - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings564_36[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings564_37[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode564(x64Operand &operand) { - operand.values[23] = OpcodeCodings564_23; - operand.values[19] = OpcodeCodings564_19; - asmError rv = ParseOperands(tokenBranches8736, operand); + operand.values[39] = OpcodeCodings564_39; + operand.values[36] = OpcodeCodings564_36; + operand.values[37] = OpcodeCodings564_37; + asmError rv; + { + rv = Opcode29(operand); + } return rv; } Coding x64Parser::OpcodeCodings565_39[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_36[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_37[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode565(x64Operand &operand) @@ -45394,60 +45434,71 @@ asmError x64Parser::Opcode565(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings566_39[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings566_36[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings566_23[] = { + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings566_37[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings566_19[] = { + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode566(x64Operand &operand) { - operand.values[39] = OpcodeCodings566_39; - operand.values[36] = OpcodeCodings566_36; - operand.values[37] = OpcodeCodings566_37; - asmError rv; - { - rv = Opcode29(operand); - } + operand.values[23] = OpcodeCodings566_23; + operand.values[19] = OpcodeCodings566_19; + asmError rv = ParseOperands(tokenBranches8742, operand); return rv; } -Coding x64Parser::OpcodeCodings567_19[] = { - { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings567_39[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings567_36[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings567_37[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode567(x64Operand &operand) { - operand.values[19] = OpcodeCodings567_19; + operand.values[39] = OpcodeCodings567_39; + operand.values[36] = OpcodeCodings567_36; + operand.values[37] = OpcodeCodings567_37; asmError rv; { - rv = Opcode27(operand); + rv = Opcode29(operand); } return rv; } -Coding x64Parser::OpcodeCodings568_19[] = { - { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings568_39[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings568_36[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings568_37[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode568(x64Operand &operand) { - operand.values[19] = OpcodeCodings568_19; + operand.values[39] = OpcodeCodings568_39; + operand.values[36] = OpcodeCodings568_36; + operand.values[37] = OpcodeCodings568_37; asmError rv; { - rv = Opcode27(operand); + rv = Opcode29(operand); } return rv; } Coding x64Parser::OpcodeCodings569_19[] = { - { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode569(x64Operand &operand) @@ -45460,8 +45511,8 @@ asmError x64Parser::Opcode569(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings570_19[] = { - { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode570(x64Operand &operand) @@ -45474,8 +45525,8 @@ asmError x64Parser::Opcode570(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings571_19[] = { - { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode571(x64Operand &operand) @@ -45488,8 +45539,8 @@ asmError x64Parser::Opcode571(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings572_19[] = { - { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode572(x64Operand &operand) @@ -45502,8 +45553,8 @@ asmError x64Parser::Opcode572(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings573_19[] = { - { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode573(x64Operand &operand) @@ -45516,8 +45567,8 @@ asmError x64Parser::Opcode573(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings574_19[] = { - { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode574(x64Operand &operand) @@ -45530,8 +45581,8 @@ asmError x64Parser::Opcode574(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings575_19[] = { - { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode575(x64Operand &operand) @@ -45543,28 +45594,23 @@ asmError x64Parser::Opcode575(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings576_23[] = { - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings576_19[] = { - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode576(x64Operand &operand) { - operand.values[23] = OpcodeCodings576_23; operand.values[19] = OpcodeCodings576_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings577_19[] = { - { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode577(x64Operand &operand) @@ -45576,23 +45622,28 @@ asmError x64Parser::Opcode577(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings578_23[] = { + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; Coding x64Parser::OpcodeCodings578_19[] = { - { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode578(x64Operand &operand) { + operand.values[23] = OpcodeCodings578_23; operand.values[19] = OpcodeCodings578_19; asmError rv; { - rv = Opcode27(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings579_19[] = { - { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode579(x64Operand &operand) @@ -45604,28 +45655,23 @@ asmError x64Parser::Opcode579(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings580_23[] = { - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings580_19[] = { - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode580(x64Operand &operand) { - operand.values[23] = OpcodeCodings580_23; operand.values[19] = OpcodeCodings580_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings581_19[] = { - { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode581(x64Operand &operand) @@ -45637,65 +45683,59 @@ asmError x64Parser::Opcode581(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings582_23[] = { + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; Coding x64Parser::OpcodeCodings582_19[] = { - { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode582(x64Operand &operand) { + operand.values[23] = OpcodeCodings582_23; operand.values[19] = OpcodeCodings582_19; asmError rv; { - rv = Opcode27(operand); + rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings583_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings583_19[] = { - { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode583(x64Operand &operand) { - operand.values[23] = OpcodeCodings583_23; operand.values[19] = OpcodeCodings583_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings584_23[] = { - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings584_19[] = { - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode584(x64Operand &operand) { - operand.values[23] = OpcodeCodings584_23; operand.values[19] = OpcodeCodings584_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings585_23[] = { - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings585_19[] = { - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode585(x64Operand &operand) @@ -45704,18 +45744,17 @@ asmError x64Parser::Opcode585(x64Operand &operand) operand.values[19] = OpcodeCodings585_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings586_23[] = { - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings586_19[] = { - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode586(x64Operand &operand) @@ -45724,18 +45763,18 @@ asmError x64Parser::Opcode586(x64Operand &operand) operand.values[19] = OpcodeCodings586_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings587_23[] = { - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings587_19[] = { - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode587(x64Operand &operand) @@ -45749,13 +45788,13 @@ asmError x64Parser::Opcode587(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings588_23[] = { - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings588_19[] = { - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode588(x64Operand &operand) @@ -45769,11 +45808,13 @@ asmError x64Parser::Opcode588(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings589_23[] = { + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings589_19[] = { - { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode589(x64Operand &operand) @@ -45782,17 +45823,18 @@ asmError x64Parser::Opcode589(x64Operand &operand) operand.values[19] = OpcodeCodings589_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings590_23[] = { - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings590_19[] = { - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode590(x64Operand &operand) @@ -45801,17 +45843,16 @@ asmError x64Parser::Opcode590(x64Operand &operand) operand.values[19] = OpcodeCodings590_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings591_23[] = { - { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings591_19[] = { - { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode591(x64Operand &operand) @@ -45820,16 +45861,17 @@ asmError x64Parser::Opcode591(x64Operand &operand) operand.values[19] = OpcodeCodings591_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings592_23[] = { + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings592_19[] = { - { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode592(x64Operand &operand) @@ -45838,17 +45880,17 @@ asmError x64Parser::Opcode592(x64Operand &operand) operand.values[19] = OpcodeCodings592_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings593_23[] = { - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings593_19[] = { - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode593(x64Operand &operand) @@ -45857,7 +45899,7 @@ asmError x64Parser::Opcode593(x64Operand &operand) operand.values[19] = OpcodeCodings593_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } @@ -45865,8 +45907,8 @@ Coding x64Parser::OpcodeCodings594_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings594_19[] = { - { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode594(x64Operand &operand) @@ -45875,17 +45917,17 @@ asmError x64Parser::Opcode594(x64Operand &operand) operand.values[19] = OpcodeCodings594_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings595_23[] = { - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings595_19[] = { - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode595(x64Operand &operand) @@ -45899,12 +45941,11 @@ asmError x64Parser::Opcode595(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings596_23[] = { - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings596_19[] = { - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode596(x64Operand &operand) @@ -45918,12 +45959,12 @@ asmError x64Parser::Opcode596(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings597_23[] = { - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings597_19[] = { - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode597(x64Operand &operand) @@ -45937,11 +45978,12 @@ asmError x64Parser::Opcode597(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings598_23[] = { + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings598_19[] = { - { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode598(x64Operand &operand) @@ -45955,12 +45997,12 @@ asmError x64Parser::Opcode598(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings599_23[] = { - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings599_19[] = { - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode599(x64Operand &operand) @@ -45974,12 +46016,11 @@ asmError x64Parser::Opcode599(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings600_23[] = { - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings600_19[] = { - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode600(x64Operand &operand) @@ -45993,12 +46034,12 @@ asmError x64Parser::Opcode600(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings601_23[] = { - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings601_19[] = { - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode601(x64Operand &operand) @@ -46012,11 +46053,12 @@ asmError x64Parser::Opcode601(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings602_23[] = { + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings602_19[] = { - { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode602(x64Operand &operand) @@ -46030,12 +46072,12 @@ asmError x64Parser::Opcode602(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings603_23[] = { - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings603_19[] = { - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode603(x64Operand &operand) @@ -46052,8 +46094,8 @@ Coding x64Parser::OpcodeCodings604_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings604_19[] = { - { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode604(x64Operand &operand) @@ -46067,12 +46109,12 @@ asmError x64Parser::Opcode604(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings605_23[] = { - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings605_19[] = { - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode605(x64Operand &operand) @@ -46089,8 +46131,8 @@ Coding x64Parser::OpcodeCodings606_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings606_19[] = { - { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode606(x64Operand &operand) @@ -46104,12 +46146,12 @@ asmError x64Parser::Opcode606(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings607_23[] = { - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings607_19[] = { - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode607(x64Operand &operand) @@ -46126,8 +46168,8 @@ Coding x64Parser::OpcodeCodings608_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings608_19[] = { - { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode608(x64Operand &operand) @@ -46140,14 +46182,41 @@ asmError x64Parser::Opcode608(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings609_23[] = { + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings609_19[] = { + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode609(x64Operand &operand) { - asmError rv = AERR_NONE; + operand.values[23] = OpcodeCodings609_23; + operand.values[19] = OpcodeCodings609_19; + asmError rv; + { + rv = Opcode19(operand); + } return rv; } +Coding x64Parser::OpcodeCodings610_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings610_19[] = { + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode610(x64Operand &operand) { - asmError rv = AERR_NONE; + operand.values[23] = OpcodeCodings610_23; + operand.values[19] = OpcodeCodings610_19; + asmError rv; + { + rv = Opcode19(operand); + } return rv; } asmError x64Parser::Opcode611(x64Operand &operand) @@ -46200,7 +46269,17 @@ asmError x64Parser::Opcode620(x64Operand &operand) asmError rv = AERR_NONE; return rv; } -x64Parser::DispatchType x64Parser::DispatchTable[621] = { +asmError x64Parser::Opcode621(x64Operand &operand) +{ + asmError rv = AERR_NONE; + return rv; +} +asmError x64Parser::Opcode622(x64Operand &operand) +{ + asmError rv = AERR_NONE; + return rv; +} +x64Parser::DispatchType x64Parser::DispatchTable[623] = { NULL, NULL, NULL, @@ -46822,6 +46901,8 @@ x64Parser::DispatchType x64Parser::DispatchTable[621] = { &x64Parser::Opcode618, &x64Parser::Opcode619, &x64Parser::Opcode620, + &x64Parser::Opcode621, + &x64Parser::Opcode622, }; x64Token *x64Parser::addressTable[] = { @@ -55219,32 +55300,36 @@ Coding x64Parser::Coding501[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding502[] = { + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::Coding503[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding503[] = { +Coding x64Parser::Coding504[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding504[] = { +Coding x64Parser::Coding505[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding505[] = { +Coding x64Parser::Coding506[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding506[] = { +Coding x64Parser::Coding507[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55256,7 +55341,7 @@ Coding x64Parser::Coding506[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding507[] = { +Coding x64Parser::Coding508[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55268,7 +55353,7 @@ Coding x64Parser::Coding507[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding508[] = { +Coding x64Parser::Coding509[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55280,7 +55365,7 @@ Coding x64Parser::Coding508[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding509[] = { +Coding x64Parser::Coding510[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55292,7 +55377,7 @@ Coding x64Parser::Coding509[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding510[] = { +Coding x64Parser::Coding511[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55304,7 +55389,7 @@ Coding x64Parser::Coding510[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding511[] = { +Coding x64Parser::Coding512[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55316,79 +55401,79 @@ Coding x64Parser::Coding511[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding512[] = { +Coding x64Parser::Coding513[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding513[] = { +Coding x64Parser::Coding514[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding514[] = { +Coding x64Parser::Coding515[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding515[] = { +Coding x64Parser::Coding516[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding516[] = { +Coding x64Parser::Coding517[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding517[] = { +Coding x64Parser::Coding518[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding518[] = { +Coding x64Parser::Coding519[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding519[] = { +Coding x64Parser::Coding520[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding520[] = { +Coding x64Parser::Coding521[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding521[] = { +Coding x64Parser::Coding522[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding522[] = { +Coding x64Parser::Coding523[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding523[] = { +Coding x64Parser::Coding524[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding524[] = { +Coding x64Parser::Coding525[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55396,14 +55481,14 @@ Coding x64Parser::Coding524[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding525[] = { +Coding x64Parser::Coding526[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding526[] = { +Coding x64Parser::Coding527[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55411,14 +55496,14 @@ Coding x64Parser::Coding526[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding527[] = { +Coding x64Parser::Coding528[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding528[] = { +Coding x64Parser::Coding529[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55426,7 +55511,7 @@ Coding x64Parser::Coding528[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding529[] = { +Coding x64Parser::Coding530[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55434,7 +55519,7 @@ Coding x64Parser::Coding529[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding530[] = { +Coding x64Parser::Coding531[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55443,7 +55528,7 @@ Coding x64Parser::Coding530[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding531[] = { +Coding x64Parser::Coding532[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55451,7 +55536,7 @@ Coding x64Parser::Coding531[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding532[] = { +Coding x64Parser::Coding533[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55460,7 +55545,7 @@ Coding x64Parser::Coding532[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding533[] = { +Coding x64Parser::Coding534[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55468,7 +55553,7 @@ Coding x64Parser::Coding533[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding534[] = { +Coding x64Parser::Coding535[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55477,7 +55562,7 @@ Coding x64Parser::Coding534[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding535[] = { +Coding x64Parser::Coding536[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55485,7 +55570,7 @@ Coding x64Parser::Coding535[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding536[] = { +Coding x64Parser::Coding537[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55494,7 +55579,7 @@ Coding x64Parser::Coding536[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding537[] = { +Coding x64Parser::Coding538[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55502,7 +55587,7 @@ Coding x64Parser::Coding537[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding538[] = { +Coding x64Parser::Coding539[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55511,7 +55596,7 @@ Coding x64Parser::Coding538[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding539[] = { +Coding x64Parser::Coding540[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55519,7 +55604,7 @@ Coding x64Parser::Coding539[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding540[] = { +Coding x64Parser::Coding541[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55528,33 +55613,33 @@ Coding x64Parser::Coding540[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding541[] = { +Coding x64Parser::Coding542[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding542[] = { +Coding x64Parser::Coding543[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding543[] = { +Coding x64Parser::Coding544[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding544[] = { +Coding x64Parser::Coding545[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding545[] = { +Coding x64Parser::Coding546[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, @@ -55562,7 +55647,7 @@ Coding x64Parser::Coding545[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding546[] = { +Coding x64Parser::Coding547[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, @@ -55570,7 +55655,7 @@ Coding x64Parser::Coding546[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding547[] = { +Coding x64Parser::Coding548[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, @@ -55580,7 +55665,7 @@ Coding x64Parser::Coding547[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding548[] = { +Coding x64Parser::Coding549[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, @@ -55590,73 +55675,73 @@ Coding x64Parser::Coding548[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding549[] = { +Coding x64Parser::Coding550[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding550[] = { +Coding x64Parser::Coding551[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding551[] = { +Coding x64Parser::Coding552[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding552[] = { +Coding x64Parser::Coding553[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding553[] = { +Coding x64Parser::Coding554[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding554[] = { +Coding x64Parser::Coding555[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding555[] = { +Coding x64Parser::Coding556[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding556[] = { +Coding x64Parser::Coding557[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding557[] = { +Coding x64Parser::Coding558[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding558[] = { +Coding x64Parser::Coding559[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding559[] = { +Coding x64Parser::Coding560[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55664,14 +55749,14 @@ Coding x64Parser::Coding559[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding560[] = { +Coding x64Parser::Coding561[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding561[] = { +Coding x64Parser::Coding562[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55679,14 +55764,14 @@ Coding x64Parser::Coding561[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding562[] = { +Coding x64Parser::Coding563[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding563[] = { +Coding x64Parser::Coding564[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55694,14 +55779,14 @@ Coding x64Parser::Coding563[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding564[] = { +Coding x64Parser::Coding565[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding565[] = { +Coding x64Parser::Coding566[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55709,14 +55794,14 @@ Coding x64Parser::Coding565[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding566[] = { +Coding x64Parser::Coding567[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding567[] = { +Coding x64Parser::Coding568[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55724,14 +55809,14 @@ Coding x64Parser::Coding567[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding568[] = { +Coding x64Parser::Coding569[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding569[] = { +Coding x64Parser::Coding570[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55739,14 +55824,14 @@ Coding x64Parser::Coding569[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding570[] = { +Coding x64Parser::Coding571[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding571[] = { +Coding x64Parser::Coding572[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55754,14 +55839,14 @@ Coding x64Parser::Coding571[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding572[] = { +Coding x64Parser::Coding573[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding573[] = { +Coding x64Parser::Coding574[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55769,38 +55854,38 @@ Coding x64Parser::Coding573[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding574[] = { +Coding x64Parser::Coding575[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding575[] = { +Coding x64Parser::Coding576[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding576[] = { +Coding x64Parser::Coding577[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding577[] = { +Coding x64Parser::Coding578[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding578[] = { +Coding x64Parser::Coding579[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding579[] = { +Coding x64Parser::Coding580[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55808,14 +55893,14 @@ Coding x64Parser::Coding579[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding580[] = { +Coding x64Parser::Coding581[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding581[] = { +Coding x64Parser::Coding582[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55823,7 +55908,7 @@ Coding x64Parser::Coding581[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding582[] = { +Coding x64Parser::Coding583[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55831,7 +55916,7 @@ Coding x64Parser::Coding582[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding583[] = { +Coding x64Parser::Coding584[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55840,7 +55925,7 @@ Coding x64Parser::Coding583[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding584[] = { +Coding x64Parser::Coding585[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55848,7 +55933,7 @@ Coding x64Parser::Coding584[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding585[] = { +Coding x64Parser::Coding586[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55857,7 +55942,7 @@ Coding x64Parser::Coding585[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding586[] = { +Coding x64Parser::Coding587[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55865,7 +55950,7 @@ Coding x64Parser::Coding586[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding587[] = { +Coding x64Parser::Coding588[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55874,7 +55959,7 @@ Coding x64Parser::Coding587[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding588[] = { +Coding x64Parser::Coding589[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55882,7 +55967,7 @@ Coding x64Parser::Coding588[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding589[] = { +Coding x64Parser::Coding590[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55891,7 +55976,7 @@ Coding x64Parser::Coding589[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding590[] = { +Coding x64Parser::Coding591[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, @@ -55899,7 +55984,7 @@ Coding x64Parser::Coding590[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding591[] = { +Coding x64Parser::Coding592[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55908,7 +55993,7 @@ Coding x64Parser::Coding591[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding592[] = { +Coding x64Parser::Coding593[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55917,7 +56002,7 @@ Coding x64Parser::Coding592[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding593[] = { +Coding x64Parser::Coding594[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55926,7 +56011,7 @@ Coding x64Parser::Coding593[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding594[] = { +Coding x64Parser::Coding595[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55935,14 +56020,14 @@ Coding x64Parser::Coding594[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding595[] = { +Coding x64Parser::Coding596[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding596[] = { +Coding x64Parser::Coding597[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55950,14 +56035,14 @@ Coding x64Parser::Coding596[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding597[] = { +Coding x64Parser::Coding598[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding598[] = { +Coding x64Parser::Coding599[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55965,7 +56050,7 @@ Coding x64Parser::Coding598[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding599[] = { +Coding x64Parser::Coding600[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55973,7 +56058,7 @@ Coding x64Parser::Coding599[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding600[] = { +Coding x64Parser::Coding601[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55982,7 +56067,7 @@ Coding x64Parser::Coding600[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding601[] = { +Coding x64Parser::Coding602[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55990,7 +56075,7 @@ Coding x64Parser::Coding601[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding602[] = { +Coding x64Parser::Coding603[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55999,7 +56084,7 @@ Coding x64Parser::Coding602[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding603[] = { +Coding x64Parser::Coding604[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56007,7 +56092,7 @@ Coding x64Parser::Coding603[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding604[] = { +Coding x64Parser::Coding605[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -56016,7 +56101,7 @@ Coding x64Parser::Coding604[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding605[] = { +Coding x64Parser::Coding606[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56024,7 +56109,7 @@ Coding x64Parser::Coding605[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding606[] = { +Coding x64Parser::Coding607[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -56033,53 +56118,53 @@ Coding x64Parser::Coding606[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding607[] = { +Coding x64Parser::Coding608[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding608[] = { +Coding x64Parser::Coding609[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding609[] = { +Coding x64Parser::Coding610[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding610[] = { +Coding x64Parser::Coding611[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding611[] = { +Coding x64Parser::Coding612[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding612[] = { +Coding x64Parser::Coding613[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding613[] = { +Coding x64Parser::Coding614[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding614[] = { +Coding x64Parser::Coding615[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56087,14 +56172,14 @@ Coding x64Parser::Coding614[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding615[] = { +Coding x64Parser::Coding616[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding616[] = { +Coding x64Parser::Coding617[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56102,14 +56187,14 @@ Coding x64Parser::Coding616[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding617[] = { +Coding x64Parser::Coding618[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding618[] = { +Coding x64Parser::Coding619[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56117,14 +56202,14 @@ Coding x64Parser::Coding618[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding619[] = { +Coding x64Parser::Coding620[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding620[] = { +Coding x64Parser::Coding621[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56132,14 +56217,14 @@ Coding x64Parser::Coding620[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding621[] = { +Coding x64Parser::Coding622[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding622[] = { +Coding x64Parser::Coding623[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56147,14 +56232,14 @@ Coding x64Parser::Coding622[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding623[] = { +Coding x64Parser::Coding624[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding624[] = { +Coding x64Parser::Coding625[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56162,14 +56247,14 @@ Coding x64Parser::Coding624[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding625[] = { +Coding x64Parser::Coding626[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding626[] = { +Coding x64Parser::Coding627[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56177,76 +56262,76 @@ Coding x64Parser::Coding626[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding627[] = { +Coding x64Parser::Coding628[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding628[] = { +Coding x64Parser::Coding629[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding629[] = { +Coding x64Parser::Coding630[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding630[] = { +Coding x64Parser::Coding631[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding631[] = { +Coding x64Parser::Coding632[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding632[] = { +Coding x64Parser::Coding633[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding633[] = { +Coding x64Parser::Coding634[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding634[] = { +Coding x64Parser::Coding635[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding635[] = { +Coding x64Parser::Coding636[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding636[] = { +Coding x64Parser::Coding637[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding637[] = { +Coding x64Parser::Coding638[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding638[] = { +Coding x64Parser::Coding639[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56254,14 +56339,14 @@ Coding x64Parser::Coding638[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding639[] = { +Coding x64Parser::Coding640[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding640[] = { +Coding x64Parser::Coding641[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56269,14 +56354,14 @@ Coding x64Parser::Coding640[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding641[] = { +Coding x64Parser::Coding642[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding642[] = { +Coding x64Parser::Coding643[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56284,7 +56369,7 @@ Coding x64Parser::Coding642[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding643[] = { +Coding x64Parser::Coding644[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56292,7 +56377,7 @@ Coding x64Parser::Coding643[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding644[] = { +Coding x64Parser::Coding645[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56301,7 +56386,7 @@ Coding x64Parser::Coding644[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding645[] = { +Coding x64Parser::Coding646[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56309,7 +56394,7 @@ Coding x64Parser::Coding645[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding646[] = { +Coding x64Parser::Coding647[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56318,7 +56403,7 @@ Coding x64Parser::Coding646[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding647[] = { +Coding x64Parser::Coding648[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56326,7 +56411,7 @@ Coding x64Parser::Coding647[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding648[] = { +Coding x64Parser::Coding649[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56335,7 +56420,7 @@ Coding x64Parser::Coding648[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding649[] = { +Coding x64Parser::Coding650[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56343,7 +56428,7 @@ Coding x64Parser::Coding649[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding650[] = { +Coding x64Parser::Coding651[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56352,7 +56437,7 @@ Coding x64Parser::Coding650[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding651[] = { +Coding x64Parser::Coding652[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56360,7 +56445,7 @@ Coding x64Parser::Coding651[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding652[] = { +Coding x64Parser::Coding653[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56369,7 +56454,7 @@ Coding x64Parser::Coding652[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding653[] = { +Coding x64Parser::Coding654[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56377,7 +56462,7 @@ Coding x64Parser::Coding653[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding654[] = { +Coding x64Parser::Coding655[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56386,7 +56471,7 @@ Coding x64Parser::Coding654[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding655[] = { +Coding x64Parser::Coding656[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56394,7 +56479,7 @@ Coding x64Parser::Coding655[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding656[] = { +Coding x64Parser::Coding657[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56402,7 +56487,7 @@ Coding x64Parser::Coding656[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding657[] = { +Coding x64Parser::Coding658[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56410,26 +56495,26 @@ Coding x64Parser::Coding657[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding658[] = { +Coding x64Parser::Coding659[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding659[] = { +Coding x64Parser::Coding660[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding660[] = { +Coding x64Parser::Coding661[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding661[] = { +Coding x64Parser::Coding662[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56437,7 +56522,7 @@ Coding x64Parser::Coding661[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding662[] = { +Coding x64Parser::Coding663[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56445,7 +56530,7 @@ Coding x64Parser::Coding662[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding663[] = { +Coding x64Parser::Coding664[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56453,131 +56538,131 @@ Coding x64Parser::Coding663[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding664[] = { +Coding x64Parser::Coding665[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding665[] = { +Coding x64Parser::Coding666[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding666[] = { +Coding x64Parser::Coding667[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding667[] = { +Coding x64Parser::Coding668[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding668[] = { +Coding x64Parser::Coding669[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { Coding::native }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding669[] = { +Coding x64Parser::Coding670[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { Coding::native }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding670[] = { +Coding x64Parser::Coding671[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding671[] = { +Coding x64Parser::Coding672[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding672[] = { +Coding x64Parser::Coding673[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding673[] = { +Coding x64Parser::Coding674[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding674[] = { +Coding x64Parser::Coding675[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding675[] = { +Coding x64Parser::Coding676[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding676[] = { +Coding x64Parser::Coding677[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding677[] = { +Coding x64Parser::Coding678[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding678[] = { +Coding x64Parser::Coding679[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding679[] = { +Coding x64Parser::Coding680[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding680[] = { +Coding x64Parser::Coding681[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding681[] = { +Coding x64Parser::Coding682[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding682[] = { +Coding x64Parser::Coding683[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding683[] = { +Coding x64Parser::Coding684[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding684[] = { +Coding x64Parser::Coding685[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56585,14 +56670,14 @@ Coding x64Parser::Coding684[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding685[] = { +Coding x64Parser::Coding686[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding686[] = { +Coding x64Parser::Coding687[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56600,14 +56685,14 @@ Coding x64Parser::Coding686[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding687[] = { +Coding x64Parser::Coding688[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding688[] = { +Coding x64Parser::Coding689[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56615,14 +56700,14 @@ Coding x64Parser::Coding688[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding689[] = { +Coding x64Parser::Coding690[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding690[] = { +Coding x64Parser::Coding691[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56630,14 +56715,14 @@ Coding x64Parser::Coding690[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding691[] = { +Coding x64Parser::Coding692[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding692[] = { +Coding x64Parser::Coding693[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56645,14 +56730,14 @@ Coding x64Parser::Coding692[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding693[] = { +Coding x64Parser::Coding694[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding694[] = { +Coding x64Parser::Coding695[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56660,14 +56745,14 @@ Coding x64Parser::Coding694[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding695[] = { +Coding x64Parser::Coding696[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding696[] = { +Coding x64Parser::Coding697[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56675,59 +56760,59 @@ Coding x64Parser::Coding696[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding697[] = { +Coding x64Parser::Coding698[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding698[] = { +Coding x64Parser::Coding699[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding699[] = { +Coding x64Parser::Coding700[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding700[] = { +Coding x64Parser::Coding701[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding701[] = { +Coding x64Parser::Coding702[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding702[] = { +Coding x64Parser::Coding703[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding703[] = { +Coding x64Parser::Coding704[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding704[] = { +Coding x64Parser::Coding705[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding705[] = { +Coding x64Parser::Coding706[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56735,14 +56820,14 @@ Coding x64Parser::Coding705[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding706[] = { +Coding x64Parser::Coding707[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding707[] = { +Coding x64Parser::Coding708[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56750,14 +56835,14 @@ Coding x64Parser::Coding707[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding708[] = { +Coding x64Parser::Coding709[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding709[] = { +Coding x64Parser::Coding710[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56765,14 +56850,14 @@ Coding x64Parser::Coding709[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding710[] = { +Coding x64Parser::Coding711[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding711[] = { +Coding x64Parser::Coding712[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56780,14 +56865,14 @@ Coding x64Parser::Coding711[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding712[] = { +Coding x64Parser::Coding713[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding713[] = { +Coding x64Parser::Coding714[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56795,14 +56880,14 @@ Coding x64Parser::Coding713[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding714[] = { +Coding x64Parser::Coding715[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding715[] = { +Coding x64Parser::Coding716[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56810,14 +56895,14 @@ Coding x64Parser::Coding715[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding716[] = { +Coding x64Parser::Coding717[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding717[] = { +Coding x64Parser::Coding718[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56825,40 +56910,40 @@ Coding x64Parser::Coding717[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding718[] = { +Coding x64Parser::Coding719[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding719[] = { +Coding x64Parser::Coding720[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding720[] = { +Coding x64Parser::Coding721[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding721[] = { +Coding x64Parser::Coding722[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding722[] = { +Coding x64Parser::Coding723[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding723[] = { +Coding x64Parser::Coding724[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56866,7 +56951,7 @@ Coding x64Parser::Coding723[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding724[] = { +Coding x64Parser::Coding725[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56874,7 +56959,7 @@ Coding x64Parser::Coding724[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding725[] = { +Coding x64Parser::Coding726[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56882,51 +56967,51 @@ Coding x64Parser::Coding725[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding726[] = { +Coding x64Parser::Coding727[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding727[] = { +Coding x64Parser::Coding728[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding728[] = { +Coding x64Parser::Coding729[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding729[] = { +Coding x64Parser::Coding730[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding730[] = { +Coding x64Parser::Coding731[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding731[] = { +Coding x64Parser::Coding732[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding732[] = { +Coding x64Parser::Coding733[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding * x64Parser::Codings[732] = { +Coding * x64Parser::Codings[733] = { x64Parser::Coding1, x64Parser::Coding2, x64Parser::Coding3, @@ -57659,6 +57744,7 @@ Coding * x64Parser::Codings[732] = { x64Parser::Coding730, x64Parser::Coding731, x64Parser::Coding732, + x64Parser::Coding733, }; Coding x64Parser::prefixCoding1[] = { { CODING_NAME("a16") Coding::stateFunc, 1 }, diff --git a/src/oasm/x64Parser.h b/src/oasm/x64Parser.h index 987b757d1..59ca87b45 100644 --- a/src/oasm/x64Parser.h +++ b/src/oasm/x64Parser.h @@ -3712,131 +3712,135 @@ class x64Parser : public InstructionParser static Coding tokenCoding6243_19[]; void TokenFunc6243(x64Operand &operand, int tokenPos); static x64Token tokenBranches6245[]; - void TokenFunc6246(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6253[]; - static x64Token tokenBranches6254[]; - void TokenFunc6255(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6255[]; - static x64Token tokenBranches6256[]; - static x64Token tokenBranches6257[]; - void TokenFunc6258(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6246[]; + static Coding tokenCoding6247_16[]; + static Coding tokenCoding6247_17[]; + static Coding tokenCoding6247_18[]; + static Coding tokenCoding6247_19[]; + void TokenFunc6247(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6248[]; + static x64Token tokenBranches6249[]; + static Coding tokenCoding6250_16[]; + static Coding tokenCoding6250_17[]; + static Coding tokenCoding6250_18[]; + static Coding tokenCoding6250_19[]; + void TokenFunc6250(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6251[]; + void TokenFunc6252(x64Operand &operand, int tokenPos); static x64Token tokenBranches6259[]; - void TokenFunc6260(x64Operand &operand, int tokenPos); static x64Token tokenBranches6260[]; + void TokenFunc6261(x64Operand &operand, int tokenPos); static x64Token tokenBranches6261[]; - static Coding tokenCoding6262_16[]; - static Coding tokenCoding6262_17[]; - static Coding tokenCoding6262_18[]; - static Coding tokenCoding6262_19[]; - void TokenFunc6262(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6272[]; - static x64Token tokenBranches6273[]; - static x64Token tokenBranches6274[]; - void TokenFunc6275(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6276[]; - static x64Token tokenBranches6277[]; + static x64Token tokenBranches6262[]; + static x64Token tokenBranches6263[]; + void TokenFunc6264(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6265[]; + void TokenFunc6266(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6266[]; + static x64Token tokenBranches6267[]; + static Coding tokenCoding6268_16[]; + static Coding tokenCoding6268_17[]; + static Coding tokenCoding6268_18[]; + static Coding tokenCoding6268_19[]; + void TokenFunc6268(x64Operand &operand, int tokenPos); static x64Token tokenBranches6278[]; - void TokenFunc6279(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6279[]; static x64Token tokenBranches6280[]; - static x64Token tokenBranches6281[]; + void TokenFunc6281(x64Operand &operand, int tokenPos); static x64Token tokenBranches6282[]; - void TokenFunc6283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6283[]; static x64Token tokenBranches6284[]; - static x64Token tokenBranches6285[]; + void TokenFunc6285(x64Operand &operand, int tokenPos); static x64Token tokenBranches6286[]; - void TokenFunc6287(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6287[]; static x64Token tokenBranches6288[]; - static x64Token tokenBranches6289[]; + void TokenFunc6289(x64Operand &operand, int tokenPos); static x64Token tokenBranches6290[]; - void TokenFunc6291(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6291[]; static x64Token tokenBranches6292[]; - static x64Token tokenBranches6293[]; + void TokenFunc6293(x64Operand &operand, int tokenPos); static x64Token tokenBranches6294[]; - void TokenFunc6295(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6295[]; static x64Token tokenBranches6296[]; - static x64Token tokenBranches6297[]; + void TokenFunc6297(x64Operand &operand, int tokenPos); static x64Token tokenBranches6298[]; - void TokenFunc6299(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6299[]; static x64Token tokenBranches6300[]; - static x64Token tokenBranches6301[]; + void TokenFunc6301(x64Operand &operand, int tokenPos); static x64Token tokenBranches6302[]; - void TokenFunc6303(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6303[]; static x64Token tokenBranches6304[]; - static x64Token tokenBranches6305[]; + void TokenFunc6305(x64Operand &operand, int tokenPos); static x64Token tokenBranches6306[]; - void TokenFunc6307(x64Operand &operand, int tokenPos); - void TokenFunc6308(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6309[]; - static Coding tokenCoding6310_16[]; - static Coding tokenCoding6310_17[]; - static Coding tokenCoding6310_19[]; - void TokenFunc6310(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6307[]; + static x64Token tokenBranches6308[]; + void TokenFunc6309(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6310[]; static x64Token tokenBranches6311[]; - static Coding tokenCoding6312_16[]; - static Coding tokenCoding6312_17[]; - static Coding tokenCoding6312_19[]; - void TokenFunc6312(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6313[]; - static x64Token tokenBranches6314[]; + static x64Token tokenBranches6312[]; + void TokenFunc6313(x64Operand &operand, int tokenPos); + void TokenFunc6314(x64Operand &operand, int tokenPos); static x64Token tokenBranches6315[]; + static Coding tokenCoding6316_16[]; + static Coding tokenCoding6316_17[]; + static Coding tokenCoding6316_19[]; void TokenFunc6316(x64Operand &operand, int tokenPos); static x64Token tokenBranches6317[]; - static x64Token tokenBranches6318[]; + static Coding tokenCoding6318_16[]; + static Coding tokenCoding6318_17[]; + static Coding tokenCoding6318_19[]; + void TokenFunc6318(x64Operand &operand, int tokenPos); static x64Token tokenBranches6319[]; - void TokenFunc6320(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6320[]; static x64Token tokenBranches6321[]; void TokenFunc6322(x64Operand &operand, int tokenPos); static x64Token tokenBranches6323[]; - static Coding tokenCoding6324_16[]; - static Coding tokenCoding6324_17[]; - static Coding tokenCoding6324_19[]; - void TokenFunc6324(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6324[]; static x64Token tokenBranches6325[]; - static Coding tokenCoding6326_16[]; - static Coding tokenCoding6326_17[]; - static Coding tokenCoding6326_19[]; void TokenFunc6326(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6336[]; - static Coding tokenCoding6337_18[]; - static Coding tokenCoding6337_19[]; - void TokenFunc6337(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6338[]; - static Coding tokenCoding6339_18[]; - static Coding tokenCoding6339_19[]; - void TokenFunc6339(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6345[]; - static x64Token tokenBranches6346[]; - static Coding tokenCoding6347_16[]; - static Coding tokenCoding6347_17[]; - static Coding tokenCoding6347_18[]; - static Coding tokenCoding6347_19[]; - void TokenFunc6347(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6348[]; - static Coding tokenCoding6349_16[]; - static Coding tokenCoding6349_17[]; - static Coding tokenCoding6349_18[]; - static Coding tokenCoding6349_19[]; - void TokenFunc6349(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6350[]; - static Coding tokenCoding6351_16[]; - static Coding tokenCoding6351_17[]; - static Coding tokenCoding6351_18[]; - static Coding tokenCoding6351_19[]; - void TokenFunc6351(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6357[]; - static x64Token tokenBranches6358[]; - static Coding tokenCoding6359_16[]; - static Coding tokenCoding6359_17[]; - static Coding tokenCoding6359_18[]; - static Coding tokenCoding6359_19[]; - void TokenFunc6359(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6360[]; - static Coding tokenCoding6361_16[]; - static Coding tokenCoding6361_17[]; - static Coding tokenCoding6361_18[]; - static Coding tokenCoding6361_19[]; - void TokenFunc6361(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6327[]; + void TokenFunc6328(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6329[]; + static Coding tokenCoding6330_16[]; + static Coding tokenCoding6330_17[]; + static Coding tokenCoding6330_19[]; + void TokenFunc6330(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6331[]; + static Coding tokenCoding6332_16[]; + static Coding tokenCoding6332_17[]; + static Coding tokenCoding6332_19[]; + void TokenFunc6332(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6342[]; + static Coding tokenCoding6343_18[]; + static Coding tokenCoding6343_19[]; + void TokenFunc6343(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6344[]; + static Coding tokenCoding6345_18[]; + static Coding tokenCoding6345_19[]; + void TokenFunc6345(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6351[]; + static x64Token tokenBranches6352[]; + static Coding tokenCoding6353_16[]; + static Coding tokenCoding6353_17[]; + static Coding tokenCoding6353_18[]; + static Coding tokenCoding6353_19[]; + void TokenFunc6353(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6354[]; + static Coding tokenCoding6355_16[]; + static Coding tokenCoding6355_17[]; + static Coding tokenCoding6355_18[]; + static Coding tokenCoding6355_19[]; + void TokenFunc6355(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6356[]; + static Coding tokenCoding6357_16[]; + static Coding tokenCoding6357_17[]; + static Coding tokenCoding6357_18[]; + static Coding tokenCoding6357_19[]; + void TokenFunc6357(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6363[]; static x64Token tokenBranches6364[]; + static Coding tokenCoding6365_16[]; + static Coding tokenCoding6365_17[]; static Coding tokenCoding6365_18[]; static Coding tokenCoding6365_19[]; void TokenFunc6365(x64Operand &operand, int tokenPos); @@ -3846,19 +3850,16 @@ class x64Parser : public InstructionParser static Coding tokenCoding6367_18[]; static Coding tokenCoding6367_19[]; void TokenFunc6367(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6368[]; - static Coding tokenCoding6369_16[]; - static Coding tokenCoding6369_17[]; - static Coding tokenCoding6369_18[]; - static Coding tokenCoding6369_19[]; - void TokenFunc6369(x64Operand &operand, int tokenPos); static x64Token tokenBranches6370[]; - static Coding tokenCoding6371_16[]; - static Coding tokenCoding6371_17[]; static Coding tokenCoding6371_18[]; static Coding tokenCoding6371_19[]; void TokenFunc6371(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6373[]; + static x64Token tokenBranches6372[]; + static Coding tokenCoding6373_16[]; + static Coding tokenCoding6373_17[]; + static Coding tokenCoding6373_18[]; + static Coding tokenCoding6373_19[]; + void TokenFunc6373(x64Operand &operand, int tokenPos); static x64Token tokenBranches6374[]; static Coding tokenCoding6375_16[]; static Coding tokenCoding6375_17[]; @@ -3871,48 +3872,47 @@ class x64Parser : public InstructionParser static Coding tokenCoding6377_18[]; static Coding tokenCoding6377_19[]; void TokenFunc6377(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6387[]; - static Coding tokenCoding6388_16[]; - static Coding tokenCoding6388_17[]; - static Coding tokenCoding6388_18[]; - static Coding tokenCoding6388_19[]; - void TokenFunc6388(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6394[]; - static Coding tokenCoding6395_16[]; - static Coding tokenCoding6395_17[]; - static Coding tokenCoding6395_18[]; - static Coding tokenCoding6395_19[]; - void TokenFunc6395(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6396[]; - static Coding tokenCoding6397_16[]; - static Coding tokenCoding6397_17[]; - static Coding tokenCoding6397_18[]; - static Coding tokenCoding6397_19[]; - void TokenFunc6397(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6403[]; - static Coding tokenCoding6404_18[]; - static Coding tokenCoding6404_19[]; - void TokenFunc6404(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6405[]; - static Coding tokenCoding6406_16[]; - static Coding tokenCoding6406_17[]; - static Coding tokenCoding6406_18[]; - static Coding tokenCoding6406_19[]; - void TokenFunc6406(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6407[]; - static Coding tokenCoding6408_16[]; - static Coding tokenCoding6408_17[]; - static Coding tokenCoding6408_18[]; - static Coding tokenCoding6408_19[]; - void TokenFunc6408(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6379[]; + static x64Token tokenBranches6380[]; + static Coding tokenCoding6381_16[]; + static Coding tokenCoding6381_17[]; + static Coding tokenCoding6381_18[]; + static Coding tokenCoding6381_19[]; + void TokenFunc6381(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6382[]; + static Coding tokenCoding6383_16[]; + static Coding tokenCoding6383_17[]; + static Coding tokenCoding6383_18[]; + static Coding tokenCoding6383_19[]; + void TokenFunc6383(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6393[]; + static Coding tokenCoding6394_16[]; + static Coding tokenCoding6394_17[]; + static Coding tokenCoding6394_18[]; + static Coding tokenCoding6394_19[]; + void TokenFunc6394(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6400[]; + static Coding tokenCoding6401_16[]; + static Coding tokenCoding6401_17[]; + static Coding tokenCoding6401_18[]; + static Coding tokenCoding6401_19[]; + void TokenFunc6401(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6402[]; + static Coding tokenCoding6403_16[]; + static Coding tokenCoding6403_17[]; + static Coding tokenCoding6403_18[]; + static Coding tokenCoding6403_19[]; + void TokenFunc6403(x64Operand &operand, int tokenPos); static x64Token tokenBranches6409[]; - static x64Token tokenBranches6410[]; - static Coding tokenCoding6411_16[]; - static Coding tokenCoding6411_17[]; - static Coding tokenCoding6411_18[]; - static Coding tokenCoding6411_19[]; - void TokenFunc6411(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6412[]; + static Coding tokenCoding6410_18[]; + static Coding tokenCoding6410_19[]; + void TokenFunc6410(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6411[]; + static Coding tokenCoding6412_16[]; + static Coding tokenCoding6412_17[]; + static Coding tokenCoding6412_18[]; + static Coding tokenCoding6412_19[]; + void TokenFunc6412(x64Operand &operand, int tokenPos); static x64Token tokenBranches6413[]; static Coding tokenCoding6414_16[]; static Coding tokenCoding6414_17[]; @@ -3920,18 +3920,16 @@ class x64Parser : public InstructionParser static Coding tokenCoding6414_19[]; void TokenFunc6414(x64Operand &operand, int tokenPos); static x64Token tokenBranches6415[]; - static Coding tokenCoding6416_16[]; - static Coding tokenCoding6416_17[]; - static Coding tokenCoding6416_18[]; - static Coding tokenCoding6416_19[]; - void TokenFunc6416(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6417[]; - static Coding tokenCoding6418_16[]; - static Coding tokenCoding6418_17[]; - static Coding tokenCoding6418_18[]; - static Coding tokenCoding6418_19[]; - void TokenFunc6418(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6416[]; + static Coding tokenCoding6417_16[]; + static Coding tokenCoding6417_17[]; + static Coding tokenCoding6417_18[]; + static Coding tokenCoding6417_19[]; + void TokenFunc6417(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6418[]; static x64Token tokenBranches6419[]; + static Coding tokenCoding6420_16[]; + static Coding tokenCoding6420_17[]; static Coding tokenCoding6420_18[]; static Coding tokenCoding6420_19[]; void TokenFunc6420(x64Operand &operand, int tokenPos); @@ -3948,149 +3946,147 @@ class x64Parser : public InstructionParser static Coding tokenCoding6424_19[]; void TokenFunc6424(x64Operand &operand, int tokenPos); static x64Token tokenBranches6425[]; - static Coding tokenCoding6426_16[]; - static Coding tokenCoding6426_17[]; static Coding tokenCoding6426_18[]; static Coding tokenCoding6426_19[]; void TokenFunc6426(x64Operand &operand, int tokenPos); static x64Token tokenBranches6427[]; - static x64Token tokenBranches6428[]; - static Coding tokenCoding6429_16[]; - static Coding tokenCoding6429_17[]; - static Coding tokenCoding6429_18[]; - static Coding tokenCoding6429_19[]; - void TokenFunc6429(x64Operand &operand, int tokenPos); + static Coding tokenCoding6428_16[]; + static Coding tokenCoding6428_17[]; + static Coding tokenCoding6428_18[]; + static Coding tokenCoding6428_19[]; + void TokenFunc6428(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6429[]; + static Coding tokenCoding6430_16[]; + static Coding tokenCoding6430_17[]; + static Coding tokenCoding6430_18[]; + static Coding tokenCoding6430_19[]; void TokenFunc6430(x64Operand &operand, int tokenPos); static x64Token tokenBranches6431[]; - static x64Token tokenBranches6432[]; - static Coding tokenCoding6433_16[]; - static Coding tokenCoding6433_17[]; - static Coding tokenCoding6433_18[]; - static Coding tokenCoding6433_19[]; - void TokenFunc6433(x64Operand &operand, int tokenPos); - void TokenFunc6434(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6441[]; - static x64Token tokenBranches6442[]; - static x64Token tokenBranches6443[]; - void TokenFunc6444(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6445[]; - static x64Token tokenBranches6446[]; + static Coding tokenCoding6432_16[]; + static Coding tokenCoding6432_17[]; + static Coding tokenCoding6432_18[]; + static Coding tokenCoding6432_19[]; + void TokenFunc6432(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6433[]; + static x64Token tokenBranches6434[]; + static Coding tokenCoding6435_16[]; + static Coding tokenCoding6435_17[]; + static Coding tokenCoding6435_18[]; + static Coding tokenCoding6435_19[]; + void TokenFunc6435(x64Operand &operand, int tokenPos); + void TokenFunc6436(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6437[]; + static x64Token tokenBranches6438[]; + static Coding tokenCoding6439_16[]; + static Coding tokenCoding6439_17[]; + static Coding tokenCoding6439_18[]; + static Coding tokenCoding6439_19[]; + void TokenFunc6439(x64Operand &operand, int tokenPos); + void TokenFunc6440(x64Operand &operand, int tokenPos); static x64Token tokenBranches6447[]; - void TokenFunc6448(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6454[]; - static x64Token tokenBranches6455[]; - static x64Token tokenBranches6456[]; - void TokenFunc6457(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6458[]; - static x64Token tokenBranches6459[]; + static x64Token tokenBranches6448[]; + static x64Token tokenBranches6449[]; + void TokenFunc6450(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6451[]; + static x64Token tokenBranches6452[]; + static x64Token tokenBranches6453[]; + void TokenFunc6454(x64Operand &operand, int tokenPos); static x64Token tokenBranches6460[]; - void TokenFunc6461(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6461[]; static x64Token tokenBranches6462[]; - static Coding tokenCoding6463_16[]; - static Coding tokenCoding6463_17[]; - static Coding tokenCoding6463_18[]; - static Coding tokenCoding6463_19[]; void TokenFunc6463(x64Operand &operand, int tokenPos); static x64Token tokenBranches6464[]; - static Coding tokenCoding6465_16[]; - static Coding tokenCoding6465_17[]; - static Coding tokenCoding6465_18[]; - static Coding tokenCoding6465_19[]; - void TokenFunc6465(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6472[]; - void TokenFunc6473(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6473[]; - static x64Token tokenBranches6474[]; - static x64Token tokenBranches6475[]; - void TokenFunc6476(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6465[]; + static x64Token tokenBranches6466[]; + void TokenFunc6467(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6468[]; + static Coding tokenCoding6469_16[]; + static Coding tokenCoding6469_17[]; + static Coding tokenCoding6469_18[]; + static Coding tokenCoding6469_19[]; + void TokenFunc6469(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6470[]; + static Coding tokenCoding6471_16[]; + static Coding tokenCoding6471_17[]; + static Coding tokenCoding6471_18[]; + static Coding tokenCoding6471_19[]; + void TokenFunc6471(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6478[]; + void TokenFunc6479(x64Operand &operand, int tokenPos); static x64Token tokenBranches6479[]; - void TokenFunc6480(x64Operand &operand, int tokenPos); - void TokenFunc6481(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6480[]; static x64Token tokenBranches6481[]; - static x64Token tokenBranches6482[]; - static x64Token tokenBranches6483[]; - void TokenFunc6484(x64Operand &operand, int tokenPos); + void TokenFunc6482(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6485[]; + void TokenFunc6486(x64Operand &operand, int tokenPos); + void TokenFunc6487(x64Operand &operand, int tokenPos); static x64Token tokenBranches6487[]; - void TokenFunc6488(x64Operand &operand, int tokenPos); - void TokenFunc6489(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6488[]; static x64Token tokenBranches6489[]; - static x64Token tokenBranches6490[]; - static x64Token tokenBranches6491[]; - void TokenFunc6492(x64Operand &operand, int tokenPos); + void TokenFunc6490(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6493[]; + void TokenFunc6494(x64Operand &operand, int tokenPos); + void TokenFunc6495(x64Operand &operand, int tokenPos); static x64Token tokenBranches6495[]; - void TokenFunc6496(x64Operand &operand, int tokenPos); - static Coding tokenCoding6500_16[]; - static Coding tokenCoding6500_17[]; - static Coding tokenCoding6500_18[]; - static Coding tokenCoding6500_19[]; - void TokenFunc6500(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6500[]; + static x64Token tokenBranches6496[]; + static x64Token tokenBranches6497[]; + void TokenFunc6498(x64Operand &operand, int tokenPos); static x64Token tokenBranches6501[]; - static x64Token tokenBranches6502[]; - static Coding tokenCoding6503_16[]; - static Coding tokenCoding6503_17[]; - static Coding tokenCoding6503_18[]; - static Coding tokenCoding6503_19[]; - void TokenFunc6503(x64Operand &operand, int tokenPos); + void TokenFunc6502(x64Operand &operand, int tokenPos); + static Coding tokenCoding6506_16[]; + static Coding tokenCoding6506_17[]; + static Coding tokenCoding6506_18[]; + static Coding tokenCoding6506_19[]; + void TokenFunc6506(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6506[]; + static x64Token tokenBranches6507[]; + static x64Token tokenBranches6508[]; static Coding tokenCoding6509_16[]; static Coding tokenCoding6509_17[]; static Coding tokenCoding6509_18[]; static Coding tokenCoding6509_19[]; void TokenFunc6509(x64Operand &operand, int tokenPos); - static Coding tokenCoding6517_16[]; - static Coding tokenCoding6517_17[]; - static Coding tokenCoding6517_18[]; - static Coding tokenCoding6517_19[]; - void TokenFunc6517(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6517[]; - static x64Token tokenBranches6518[]; - static x64Token tokenBranches6519[]; - static Coding tokenCoding6520_16[]; - static Coding tokenCoding6520_17[]; - static Coding tokenCoding6520_18[]; - static Coding tokenCoding6520_19[]; - void TokenFunc6520(x64Operand &operand, int tokenPos); + static Coding tokenCoding6515_16[]; + static Coding tokenCoding6515_17[]; + static Coding tokenCoding6515_18[]; + static Coding tokenCoding6515_19[]; + void TokenFunc6515(x64Operand &operand, int tokenPos); + static Coding tokenCoding6523_16[]; + static Coding tokenCoding6523_17[]; + static Coding tokenCoding6523_18[]; + static Coding tokenCoding6523_19[]; + void TokenFunc6523(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6523[]; + static x64Token tokenBranches6524[]; + static x64Token tokenBranches6525[]; static Coding tokenCoding6526_16[]; static Coding tokenCoding6526_17[]; static Coding tokenCoding6526_18[]; static Coding tokenCoding6526_19[]; void TokenFunc6526(x64Operand &operand, int tokenPos); - static Coding tokenCoding6534_16[]; - static Coding tokenCoding6534_17[]; - static Coding tokenCoding6534_18[]; - static Coding tokenCoding6534_19[]; - void TokenFunc6534(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6534[]; - static x64Token tokenBranches6535[]; - static x64Token tokenBranches6536[]; - static Coding tokenCoding6537_16[]; - static Coding tokenCoding6537_17[]; - static Coding tokenCoding6537_18[]; - static Coding tokenCoding6537_19[]; - void TokenFunc6537(x64Operand &operand, int tokenPos); + static Coding tokenCoding6532_16[]; + static Coding tokenCoding6532_17[]; + static Coding tokenCoding6532_18[]; + static Coding tokenCoding6532_19[]; + void TokenFunc6532(x64Operand &operand, int tokenPos); + static Coding tokenCoding6540_16[]; + static Coding tokenCoding6540_17[]; + static Coding tokenCoding6540_18[]; + static Coding tokenCoding6540_19[]; + void TokenFunc6540(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6540[]; + static x64Token tokenBranches6541[]; + static x64Token tokenBranches6542[]; static Coding tokenCoding6543_16[]; static Coding tokenCoding6543_17[]; static Coding tokenCoding6543_18[]; static Coding tokenCoding6543_19[]; void TokenFunc6543(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6548[]; static Coding tokenCoding6549_16[]; static Coding tokenCoding6549_17[]; static Coding tokenCoding6549_18[]; static Coding tokenCoding6549_19[]; void TokenFunc6549(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6550[]; - static Coding tokenCoding6551_16[]; - static Coding tokenCoding6551_17[]; - static Coding tokenCoding6551_18[]; - static Coding tokenCoding6551_19[]; - void TokenFunc6551(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6552[]; - static Coding tokenCoding6553_16[]; - static Coding tokenCoding6553_17[]; - static Coding tokenCoding6553_18[]; - static Coding tokenCoding6553_19[]; - void TokenFunc6553(x64Operand &operand, int tokenPos); static x64Token tokenBranches6554[]; static Coding tokenCoding6555_16[]; static Coding tokenCoding6555_17[]; @@ -4098,325 +4094,327 @@ class x64Parser : public InstructionParser static Coding tokenCoding6555_19[]; void TokenFunc6555(x64Operand &operand, int tokenPos); static x64Token tokenBranches6556[]; - static x64Token tokenBranches6557[]; + static Coding tokenCoding6557_16[]; + static Coding tokenCoding6557_17[]; + static Coding tokenCoding6557_18[]; + static Coding tokenCoding6557_19[]; + void TokenFunc6557(x64Operand &operand, int tokenPos); static x64Token tokenBranches6558[]; - static x64Token tokenBranches6559[]; - void TokenFunc6560(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6561[]; + static Coding tokenCoding6559_16[]; + static Coding tokenCoding6559_17[]; + static Coding tokenCoding6559_18[]; + static Coding tokenCoding6559_19[]; + void TokenFunc6559(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6560[]; + static Coding tokenCoding6561_16[]; + static Coding tokenCoding6561_17[]; + static Coding tokenCoding6561_18[]; + static Coding tokenCoding6561_19[]; + void TokenFunc6561(x64Operand &operand, int tokenPos); static x64Token tokenBranches6562[]; static x64Token tokenBranches6563[]; - void TokenFunc6564(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6564[]; static x64Token tokenBranches6565[]; - static x64Token tokenBranches6566[]; + void TokenFunc6566(x64Operand &operand, int tokenPos); static x64Token tokenBranches6567[]; - void TokenFunc6568(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6568[]; static x64Token tokenBranches6569[]; - static x64Token tokenBranches6570[]; + void TokenFunc6570(x64Operand &operand, int tokenPos); static x64Token tokenBranches6571[]; - void TokenFunc6572(x64Operand &operand, int tokenPos); - void TokenFunc6575(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6572[]; + static x64Token tokenBranches6573[]; + void TokenFunc6574(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6575[]; + static x64Token tokenBranches6576[]; + static x64Token tokenBranches6577[]; void TokenFunc6578(x64Operand &operand, int tokenPos); void TokenFunc6581(x64Operand &operand, int tokenPos); void TokenFunc6584(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6585[]; - static x64Token tokenBranches6586[]; - static x64Token tokenBranches6587[]; - static x64Token tokenBranches6588[]; - static x64Token tokenBranches6589[]; - static x64Token tokenBranches6590[]; + void TokenFunc6587(x64Operand &operand, int tokenPos); + void TokenFunc6590(x64Operand &operand, int tokenPos); static x64Token tokenBranches6591[]; static x64Token tokenBranches6592[]; - void TokenFunc6593(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6593[]; + static x64Token tokenBranches6594[]; static x64Token tokenBranches6595[]; - void TokenFunc6596(x64Operand &operand, int tokenPos); static x64Token tokenBranches6596[]; static x64Token tokenBranches6597[]; static x64Token tokenBranches6598[]; - static x64Token tokenBranches6599[]; - static x64Token tokenBranches6600[]; - void TokenFunc6601(x64Operand &operand, int tokenPos); + void TokenFunc6599(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6601[]; + void TokenFunc6602(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6602[]; + static x64Token tokenBranches6603[]; + static x64Token tokenBranches6604[]; + static x64Token tokenBranches6605[]; static x64Token tokenBranches6606[]; - static x64Token tokenBranches6607[]; - static x64Token tokenBranches6608[]; - void TokenFunc6609(x64Operand &operand, int tokenPos); + void TokenFunc6607(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6612[]; + static x64Token tokenBranches6613[]; static x64Token tokenBranches6614[]; - static x64Token tokenBranches6615[]; - static x64Token tokenBranches6616[]; - void TokenFunc6617(x64Operand &operand, int tokenPos); + void TokenFunc6615(x64Operand &operand, int tokenPos); static x64Token tokenBranches6620[]; static x64Token tokenBranches6621[]; static x64Token tokenBranches6622[]; void TokenFunc6623(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6626[]; + static x64Token tokenBranches6627[]; static x64Token tokenBranches6628[]; - static x64Token tokenBranches6629[]; - static x64Token tokenBranches6630[]; - void TokenFunc6631(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6632[]; - static x64Token tokenBranches6633[]; + void TokenFunc6629(x64Operand &operand, int tokenPos); static x64Token tokenBranches6634[]; static x64Token tokenBranches6635[]; static x64Token tokenBranches6636[]; - static x64Token tokenBranches6637[]; + void TokenFunc6637(x64Operand &operand, int tokenPos); static x64Token tokenBranches6638[]; - void TokenFunc6639(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6639[]; + static x64Token tokenBranches6640[]; static x64Token tokenBranches6641[]; - void TokenFunc6642(x64Operand &operand, int tokenPos); static x64Token tokenBranches6642[]; static x64Token tokenBranches6643[]; static x64Token tokenBranches6644[]; - static x64Token tokenBranches6645[]; - static x64Token tokenBranches6646[]; - void TokenFunc6647(x64Operand &operand, int tokenPos); + void TokenFunc6645(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6647[]; + void TokenFunc6648(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6648[]; + static x64Token tokenBranches6649[]; + static x64Token tokenBranches6650[]; + static x64Token tokenBranches6651[]; static x64Token tokenBranches6652[]; - static x64Token tokenBranches6653[]; - static x64Token tokenBranches6654[]; - void TokenFunc6655(x64Operand &operand, int tokenPos); + void TokenFunc6653(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6658[]; + static x64Token tokenBranches6659[]; static x64Token tokenBranches6660[]; - static x64Token tokenBranches6661[]; - static x64Token tokenBranches6662[]; - void TokenFunc6663(x64Operand &operand, int tokenPos); + void TokenFunc6661(x64Operand &operand, int tokenPos); static x64Token tokenBranches6666[]; static x64Token tokenBranches6667[]; static x64Token tokenBranches6668[]; void TokenFunc6669(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6672[]; + static x64Token tokenBranches6673[]; static x64Token tokenBranches6674[]; - static x64Token tokenBranches6675[]; - static x64Token tokenBranches6676[]; - void TokenFunc6677(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6678[]; - static x64Token tokenBranches6679[]; + void TokenFunc6675(x64Operand &operand, int tokenPos); static x64Token tokenBranches6680[]; static x64Token tokenBranches6681[]; static x64Token tokenBranches6682[]; - static x64Token tokenBranches6683[]; + void TokenFunc6683(x64Operand &operand, int tokenPos); static x64Token tokenBranches6684[]; - void TokenFunc6685(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6685[]; + static x64Token tokenBranches6686[]; static x64Token tokenBranches6687[]; - void TokenFunc6688(x64Operand &operand, int tokenPos); static x64Token tokenBranches6688[]; static x64Token tokenBranches6689[]; static x64Token tokenBranches6690[]; - static x64Token tokenBranches6691[]; - static x64Token tokenBranches6692[]; - void TokenFunc6693(x64Operand &operand, int tokenPos); + void TokenFunc6691(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6693[]; + void TokenFunc6694(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6694[]; + static x64Token tokenBranches6695[]; + static x64Token tokenBranches6696[]; + static x64Token tokenBranches6697[]; static x64Token tokenBranches6698[]; - static x64Token tokenBranches6699[]; - static x64Token tokenBranches6700[]; - void TokenFunc6701(x64Operand &operand, int tokenPos); + void TokenFunc6699(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6704[]; + static x64Token tokenBranches6705[]; static x64Token tokenBranches6706[]; - static x64Token tokenBranches6707[]; - static x64Token tokenBranches6708[]; - void TokenFunc6709(x64Operand &operand, int tokenPos); + void TokenFunc6707(x64Operand &operand, int tokenPos); static x64Token tokenBranches6712[]; static x64Token tokenBranches6713[]; static x64Token tokenBranches6714[]; void TokenFunc6715(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6718[]; + static x64Token tokenBranches6719[]; static x64Token tokenBranches6720[]; - static x64Token tokenBranches6721[]; - static x64Token tokenBranches6722[]; - void TokenFunc6723(x64Operand &operand, int tokenPos); + void TokenFunc6721(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6726[]; + static x64Token tokenBranches6727[]; static x64Token tokenBranches6728[]; - static x64Token tokenBranches6729[]; - void TokenFunc6730(x64Operand &operand, int tokenPos); + void TokenFunc6729(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6734[]; static x64Token tokenBranches6735[]; - static Coding tokenCoding6736_16[]; - static Coding tokenCoding6736_17[]; - static Coding tokenCoding6736_18[]; - static Coding tokenCoding6736_19[]; void TokenFunc6736(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6739[]; - void TokenFunc6740(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6747[]; - void TokenFunc6748(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6749[]; - void TokenFunc6750(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6756[]; - static x64Token tokenBranches6757[]; - void TokenFunc6758(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6758[]; - static x64Token tokenBranches6759[]; - static x64Token tokenBranches6760[]; - void TokenFunc6761(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6741[]; + static Coding tokenCoding6742_16[]; + static Coding tokenCoding6742_17[]; + static Coding tokenCoding6742_18[]; + static Coding tokenCoding6742_19[]; + void TokenFunc6742(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6745[]; + void TokenFunc6746(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6753[]; + void TokenFunc6754(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6755[]; + void TokenFunc6756(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6762[]; + static x64Token tokenBranches6763[]; + void TokenFunc6764(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6764[]; static x64Token tokenBranches6765[]; - void TokenFunc6766(x64Operand &operand, int tokenPos); - void TokenFunc6768(x64Operand &operand, int tokenPos); - void TokenFunc6770(x64Operand &operand, int tokenPos); - static Coding tokenCoding6772_16[]; - static Coding tokenCoding6772_17[]; - static Coding tokenCoding6772_18[]; - static Coding tokenCoding6772_19[]; + static x64Token tokenBranches6766[]; + void TokenFunc6767(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6771[]; void TokenFunc6772(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6774[]; - static Coding tokenCoding6775_16[]; - static Coding tokenCoding6775_17[]; - static Coding tokenCoding6775_18[]; - static Coding tokenCoding6775_19[]; - void TokenFunc6775(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6777[]; + void TokenFunc6774(x64Operand &operand, int tokenPos); + void TokenFunc6776(x64Operand &operand, int tokenPos); static Coding tokenCoding6778_16[]; static Coding tokenCoding6778_17[]; static Coding tokenCoding6778_18[]; static Coding tokenCoding6778_19[]; void TokenFunc6778(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6779[]; - void TokenFunc6780(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6781[]; - void TokenFunc6782(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6780[]; + static Coding tokenCoding6781_16[]; + static Coding tokenCoding6781_17[]; + static Coding tokenCoding6781_18[]; + static Coding tokenCoding6781_19[]; + void TokenFunc6781(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6783[]; + static Coding tokenCoding6784_16[]; + static Coding tokenCoding6784_17[]; + static Coding tokenCoding6784_18[]; + static Coding tokenCoding6784_19[]; void TokenFunc6784(x64Operand &operand, int tokenPos); - void TokenFunc6785(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6785[]; void TokenFunc6786(x64Operand &operand, int tokenPos); - static Coding tokenCoding6787_16[]; - static Coding tokenCoding6787_17[]; - static Coding tokenCoding6787_18[]; - static Coding tokenCoding6787_19[]; - void TokenFunc6787(x64Operand &operand, int tokenPos); - static Coding tokenCoding6788_16[]; - static Coding tokenCoding6788_17[]; - static Coding tokenCoding6788_18[]; - static Coding tokenCoding6788_19[]; + static x64Token tokenBranches6787[]; void TokenFunc6788(x64Operand &operand, int tokenPos); - static Coding tokenCoding6789_16[]; - static Coding tokenCoding6789_17[]; - static Coding tokenCoding6789_18[]; - static Coding tokenCoding6789_19[]; - void TokenFunc6789(x64Operand &operand, int tokenPos); - static Coding tokenCoding6790_16[]; - static Coding tokenCoding6790_17[]; - static Coding tokenCoding6790_18[]; - static Coding tokenCoding6790_19[]; void TokenFunc6790(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6791[]; - static Coding tokenCoding6792_16[]; - static Coding tokenCoding6792_17[]; - static Coding tokenCoding6792_18[]; - static Coding tokenCoding6792_19[]; + void TokenFunc6791(x64Operand &operand, int tokenPos); void TokenFunc6792(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6793[]; + static Coding tokenCoding6793_16[]; + static Coding tokenCoding6793_17[]; + static Coding tokenCoding6793_18[]; + static Coding tokenCoding6793_19[]; + void TokenFunc6793(x64Operand &operand, int tokenPos); static Coding tokenCoding6794_16[]; static Coding tokenCoding6794_17[]; static Coding tokenCoding6794_18[]; static Coding tokenCoding6794_19[]; void TokenFunc6794(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6795[]; + static Coding tokenCoding6795_16[]; + static Coding tokenCoding6795_17[]; + static Coding tokenCoding6795_18[]; + static Coding tokenCoding6795_19[]; + void TokenFunc6795(x64Operand &operand, int tokenPos); static Coding tokenCoding6796_16[]; static Coding tokenCoding6796_17[]; static Coding tokenCoding6796_18[]; static Coding tokenCoding6796_19[]; void TokenFunc6796(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6829[]; - static Coding tokenCoding6830_16[]; - static Coding tokenCoding6830_17[]; - static Coding tokenCoding6830_18[]; - static Coding tokenCoding6830_19[]; - void TokenFunc6830(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6831[]; - static x64Token tokenBranches6832[]; - static x64Token tokenBranches6833[]; - static x64Token tokenBranches6834[]; + static x64Token tokenBranches6797[]; + static Coding tokenCoding6798_16[]; + static Coding tokenCoding6798_17[]; + static Coding tokenCoding6798_18[]; + static Coding tokenCoding6798_19[]; + void TokenFunc6798(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6799[]; + static Coding tokenCoding6800_16[]; + static Coding tokenCoding6800_17[]; + static Coding tokenCoding6800_18[]; + static Coding tokenCoding6800_19[]; + void TokenFunc6800(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6801[]; + static Coding tokenCoding6802_16[]; + static Coding tokenCoding6802_17[]; + static Coding tokenCoding6802_18[]; + static Coding tokenCoding6802_19[]; + void TokenFunc6802(x64Operand &operand, int tokenPos); static x64Token tokenBranches6835[]; - static x64Token tokenBranches6836[]; - void TokenFunc6837(x64Operand &operand, int tokenPos); - void TokenFunc6840(x64Operand &operand, int tokenPos); + static Coding tokenCoding6836_16[]; + static Coding tokenCoding6836_17[]; + static Coding tokenCoding6836_18[]; + static Coding tokenCoding6836_19[]; + void TokenFunc6836(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6837[]; + static x64Token tokenBranches6838[]; + static x64Token tokenBranches6839[]; static x64Token tokenBranches6840[]; static x64Token tokenBranches6841[]; static x64Token tokenBranches6842[]; void TokenFunc6843(x64Operand &operand, int tokenPos); + void TokenFunc6846(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6846[]; + static x64Token tokenBranches6847[]; static x64Token tokenBranches6848[]; void TokenFunc6849(x64Operand &operand, int tokenPos); static x64Token tokenBranches6854[]; void TokenFunc6855(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6858[]; - void TokenFunc6859(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6860[]; + void TokenFunc6861(x64Operand &operand, int tokenPos); static x64Token tokenBranches6864[]; void TokenFunc6865(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6866[]; - static x64Token tokenBranches6867[]; - static x64Token tokenBranches6868[]; - static x64Token tokenBranches6869[]; static x64Token tokenBranches6870[]; void TokenFunc6871(x64Operand &operand, int tokenPos); - void TokenFunc6874(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6872[]; + static x64Token tokenBranches6873[]; static x64Token tokenBranches6874[]; static x64Token tokenBranches6875[]; static x64Token tokenBranches6876[]; void TokenFunc6877(x64Operand &operand, int tokenPos); + void TokenFunc6880(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6880[]; + static x64Token tokenBranches6881[]; static x64Token tokenBranches6882[]; void TokenFunc6883(x64Operand &operand, int tokenPos); static x64Token tokenBranches6888[]; void TokenFunc6889(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6892[]; - void TokenFunc6893(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6894[]; + void TokenFunc6895(x64Operand &operand, int tokenPos); static x64Token tokenBranches6898[]; void TokenFunc6899(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6900[]; - static x64Token tokenBranches6901[]; - static x64Token tokenBranches6902[]; - static x64Token tokenBranches6903[]; static x64Token tokenBranches6904[]; void TokenFunc6905(x64Operand &operand, int tokenPos); - void TokenFunc6908(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6906[]; + static x64Token tokenBranches6907[]; static x64Token tokenBranches6908[]; static x64Token tokenBranches6909[]; static x64Token tokenBranches6910[]; void TokenFunc6911(x64Operand &operand, int tokenPos); + void TokenFunc6914(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6914[]; + static x64Token tokenBranches6915[]; static x64Token tokenBranches6916[]; void TokenFunc6917(x64Operand &operand, int tokenPos); static x64Token tokenBranches6922[]; void TokenFunc6923(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6926[]; - void TokenFunc6927(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6928[]; + void TokenFunc6929(x64Operand &operand, int tokenPos); static x64Token tokenBranches6932[]; void TokenFunc6933(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6934[]; - static x64Token tokenBranches6935[]; - static x64Token tokenBranches6936[]; - static x64Token tokenBranches6937[]; static x64Token tokenBranches6938[]; void TokenFunc6939(x64Operand &operand, int tokenPos); - void TokenFunc6942(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6940[]; + static x64Token tokenBranches6941[]; static x64Token tokenBranches6942[]; static x64Token tokenBranches6943[]; static x64Token tokenBranches6944[]; void TokenFunc6945(x64Operand &operand, int tokenPos); + void TokenFunc6948(x64Operand &operand, int tokenPos); static x64Token tokenBranches6948[]; - void TokenFunc6949(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6949[]; + static x64Token tokenBranches6950[]; + void TokenFunc6951(x64Operand &operand, int tokenPos); static x64Token tokenBranches6954[]; void TokenFunc6955(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6959[]; - void TokenFunc6960(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6961[]; - void TokenFunc6962(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6963[]; - void TokenFunc6964(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6960[]; + void TokenFunc6961(x64Operand &operand, int tokenPos); static x64Token tokenBranches6965[]; void TokenFunc6966(x64Operand &operand, int tokenPos); static x64Token tokenBranches6967[]; void TokenFunc6968(x64Operand &operand, int tokenPos); static x64Token tokenBranches6969[]; void TokenFunc6970(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6971[]; + void TokenFunc6972(x64Operand &operand, int tokenPos); static x64Token tokenBranches6973[]; - static Coding tokenCoding6974_16[]; - static Coding tokenCoding6974_17[]; - static Coding tokenCoding6974_18[]; - static Coding tokenCoding6974_19[]; void TokenFunc6974(x64Operand &operand, int tokenPos); static x64Token tokenBranches6975[]; void TokenFunc6976(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6976[]; - static x64Token tokenBranches6977[]; - static Coding tokenCoding6978_16[]; - static Coding tokenCoding6978_17[]; - static Coding tokenCoding6978_18[]; - static Coding tokenCoding6978_19[]; - void TokenFunc6978(x64Operand &operand, int tokenPos); - void TokenFunc6979(x64Operand &operand, int tokenPos); static x64Token tokenBranches6979[]; - static x64Token tokenBranches6980[]; - static Coding tokenCoding6981_16[]; - static Coding tokenCoding6981_17[]; - static Coding tokenCoding6981_18[]; - static Coding tokenCoding6981_19[]; - void TokenFunc6981(x64Operand &operand, int tokenPos); + static Coding tokenCoding6980_16[]; + static Coding tokenCoding6980_17[]; + static Coding tokenCoding6980_18[]; + static Coding tokenCoding6980_19[]; + void TokenFunc6980(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6981[]; void TokenFunc6982(x64Operand &operand, int tokenPos); static x64Token tokenBranches6982[]; static x64Token tokenBranches6983[]; @@ -4425,291 +4423,297 @@ class x64Parser : public InstructionParser static Coding tokenCoding6984_18[]; static Coding tokenCoding6984_19[]; void TokenFunc6984(x64Operand &operand, int tokenPos); + void TokenFunc6985(x64Operand &operand, int tokenPos); static x64Token tokenBranches6985[]; static x64Token tokenBranches6986[]; - static x64Token tokenBranches6987[]; + static Coding tokenCoding6987_16[]; + static Coding tokenCoding6987_17[]; + static Coding tokenCoding6987_18[]; + static Coding tokenCoding6987_19[]; + void TokenFunc6987(x64Operand &operand, int tokenPos); + void TokenFunc6988(x64Operand &operand, int tokenPos); static x64Token tokenBranches6988[]; - void TokenFunc6989(x64Operand &operand, int tokenPos); static x64Token tokenBranches6989[]; + static Coding tokenCoding6990_16[]; + static Coding tokenCoding6990_17[]; + static Coding tokenCoding6990_18[]; + static Coding tokenCoding6990_19[]; void TokenFunc6990(x64Operand &operand, int tokenPos); + static x64Token tokenBranches6991[]; + static x64Token tokenBranches6992[]; + static x64Token tokenBranches6993[]; + static x64Token tokenBranches6994[]; void TokenFunc6995(x64Operand &operand, int tokenPos); static x64Token tokenBranches6995[]; - static x64Token tokenBranches6996[]; - void TokenFunc6997(x64Operand &operand, int tokenPos); - static x64Token tokenBranches6997[]; - void TokenFunc6998(x64Operand &operand, int tokenPos); + void TokenFunc6996(x64Operand &operand, int tokenPos); + void TokenFunc7001(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7001[]; + static x64Token tokenBranches7002[]; void TokenFunc7003(x64Operand &operand, int tokenPos); static x64Token tokenBranches7003[]; void TokenFunc7004(x64Operand &operand, int tokenPos); - void TokenFunc7011(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7011[]; - void TokenFunc7012(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7013[]; - static x64Token tokenBranches7014[]; - static x64Token tokenBranches7015[]; - static x64Token tokenBranches7016[]; + void TokenFunc7009(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7009[]; + void TokenFunc7010(x64Operand &operand, int tokenPos); void TokenFunc7017(x64Operand &operand, int tokenPos); static x64Token tokenBranches7017[]; void TokenFunc7018(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7019[]; + static x64Token tokenBranches7020[]; + static x64Token tokenBranches7021[]; + static x64Token tokenBranches7022[]; void TokenFunc7023(x64Operand &operand, int tokenPos); static x64Token tokenBranches7023[]; - static x64Token tokenBranches7024[]; - void TokenFunc7025(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7025[]; - void TokenFunc7026(x64Operand &operand, int tokenPos); + void TokenFunc7024(x64Operand &operand, int tokenPos); + void TokenFunc7029(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7029[]; + static x64Token tokenBranches7030[]; void TokenFunc7031(x64Operand &operand, int tokenPos); static x64Token tokenBranches7031[]; void TokenFunc7032(x64Operand &operand, int tokenPos); - void TokenFunc7039(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7039[]; - void TokenFunc7040(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7041[]; - static x64Token tokenBranches7042[]; - static x64Token tokenBranches7043[]; - static x64Token tokenBranches7044[]; + void TokenFunc7037(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7037[]; + void TokenFunc7038(x64Operand &operand, int tokenPos); void TokenFunc7045(x64Operand &operand, int tokenPos); static x64Token tokenBranches7045[]; void TokenFunc7046(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7047[]; + static x64Token tokenBranches7048[]; + static x64Token tokenBranches7049[]; + static x64Token tokenBranches7050[]; void TokenFunc7051(x64Operand &operand, int tokenPos); static x64Token tokenBranches7051[]; - static x64Token tokenBranches7052[]; - void TokenFunc7053(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7053[]; - void TokenFunc7054(x64Operand &operand, int tokenPos); + void TokenFunc7052(x64Operand &operand, int tokenPos); + void TokenFunc7057(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7057[]; + static x64Token tokenBranches7058[]; void TokenFunc7059(x64Operand &operand, int tokenPos); static x64Token tokenBranches7059[]; void TokenFunc7060(x64Operand &operand, int tokenPos); - void TokenFunc7067(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7067[]; - void TokenFunc7068(x64Operand &operand, int tokenPos); - void TokenFunc7069(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7069[]; - static x64Token tokenBranches7070[]; - static x64Token tokenBranches7071[]; - void TokenFunc7072(x64Operand &operand, int tokenPos); + void TokenFunc7065(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7065[]; + void TokenFunc7066(x64Operand &operand, int tokenPos); void TokenFunc7073(x64Operand &operand, int tokenPos); static x64Token tokenBranches7073[]; - static x64Token tokenBranches7074[]; + void TokenFunc7074(x64Operand &operand, int tokenPos); + void TokenFunc7075(x64Operand &operand, int tokenPos); static x64Token tokenBranches7075[]; - void TokenFunc7076(x64Operand &operand, int tokenPos); - void TokenFunc7077(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7076[]; static x64Token tokenBranches7077[]; - static x64Token tokenBranches7078[]; + void TokenFunc7078(x64Operand &operand, int tokenPos); + void TokenFunc7079(x64Operand &operand, int tokenPos); static x64Token tokenBranches7079[]; - void TokenFunc7080(x64Operand &operand, int tokenPos); - void TokenFunc7081(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7080[]; static x64Token tokenBranches7081[]; - static x64Token tokenBranches7082[]; + void TokenFunc7082(x64Operand &operand, int tokenPos); + void TokenFunc7083(x64Operand &operand, int tokenPos); static x64Token tokenBranches7083[]; - void TokenFunc7084(x64Operand &operand, int tokenPos); - void TokenFunc7085(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7084[]; static x64Token tokenBranches7085[]; - static x64Token tokenBranches7086[]; + void TokenFunc7086(x64Operand &operand, int tokenPos); + void TokenFunc7087(x64Operand &operand, int tokenPos); static x64Token tokenBranches7087[]; - void TokenFunc7088(x64Operand &operand, int tokenPos); - static Coding tokenCoding7092_16[]; - static Coding tokenCoding7092_17[]; - static Coding tokenCoding7092_18[]; - static Coding tokenCoding7092_19[]; - void TokenFunc7092(x64Operand &operand, int tokenPos); - static Coding tokenCoding7096_16[]; - static Coding tokenCoding7096_17[]; - static Coding tokenCoding7096_23[]; - static Coding tokenCoding7096_18[]; - static Coding tokenCoding7096_19[]; - void TokenFunc7096(x64Operand &operand, int tokenPos); - static Coding tokenCoding7100_16[]; - static Coding tokenCoding7100_17[]; - static Coding tokenCoding7100_18[]; - static Coding tokenCoding7100_19[]; - void TokenFunc7100(x64Operand &operand, int tokenPos); - static Coding tokenCoding7104_16[]; - static Coding tokenCoding7104_17[]; - static Coding tokenCoding7104_18[]; - static Coding tokenCoding7104_19[]; - void TokenFunc7104(x64Operand &operand, int tokenPos); - static Coding tokenCoding7108_16[]; - static Coding tokenCoding7108_17[]; - static Coding tokenCoding7108_18[]; - static Coding tokenCoding7108_19[]; - void TokenFunc7108(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7109[]; - static x64Token tokenBranches7110[]; - static x64Token tokenBranches7111[]; - static x64Token tokenBranches7112[]; - static Coding tokenCoding7113_16[]; - static Coding tokenCoding7113_17[]; - static Coding tokenCoding7113_18[]; - static Coding tokenCoding7113_19[]; - void TokenFunc7113(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7114[]; + static x64Token tokenBranches7088[]; + static x64Token tokenBranches7089[]; + void TokenFunc7090(x64Operand &operand, int tokenPos); + void TokenFunc7091(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7091[]; + static x64Token tokenBranches7092[]; + static x64Token tokenBranches7093[]; + void TokenFunc7094(x64Operand &operand, int tokenPos); + static Coding tokenCoding7098_16[]; + static Coding tokenCoding7098_17[]; + static Coding tokenCoding7098_18[]; + static Coding tokenCoding7098_19[]; + void TokenFunc7098(x64Operand &operand, int tokenPos); + static Coding tokenCoding7102_16[]; + static Coding tokenCoding7102_17[]; + static Coding tokenCoding7102_23[]; + static Coding tokenCoding7102_18[]; + static Coding tokenCoding7102_19[]; + void TokenFunc7102(x64Operand &operand, int tokenPos); + static Coding tokenCoding7106_16[]; + static Coding tokenCoding7106_17[]; + static Coding tokenCoding7106_18[]; + static Coding tokenCoding7106_19[]; + void TokenFunc7106(x64Operand &operand, int tokenPos); + static Coding tokenCoding7110_16[]; + static Coding tokenCoding7110_17[]; + static Coding tokenCoding7110_18[]; + static Coding tokenCoding7110_19[]; + void TokenFunc7110(x64Operand &operand, int tokenPos); + static Coding tokenCoding7114_16[]; + static Coding tokenCoding7114_17[]; + static Coding tokenCoding7114_18[]; + static Coding tokenCoding7114_19[]; + void TokenFunc7114(x64Operand &operand, int tokenPos); static x64Token tokenBranches7115[]; static x64Token tokenBranches7116[]; static x64Token tokenBranches7117[]; - static Coding tokenCoding7118_16[]; - static Coding tokenCoding7118_17[]; - static Coding tokenCoding7118_18[]; - static Coding tokenCoding7118_19[]; - void TokenFunc7118(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7119[]; + static x64Token tokenBranches7118[]; + static Coding tokenCoding7119_16[]; + static Coding tokenCoding7119_17[]; + static Coding tokenCoding7119_18[]; + static Coding tokenCoding7119_19[]; + void TokenFunc7119(x64Operand &operand, int tokenPos); static x64Token tokenBranches7120[]; static x64Token tokenBranches7121[]; static x64Token tokenBranches7122[]; - static Coding tokenCoding7123_16[]; - static Coding tokenCoding7123_17[]; - static Coding tokenCoding7123_18[]; - static Coding tokenCoding7123_19[]; - void TokenFunc7123(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7124[]; + static x64Token tokenBranches7123[]; + static Coding tokenCoding7124_16[]; + static Coding tokenCoding7124_17[]; + static Coding tokenCoding7124_18[]; + static Coding tokenCoding7124_19[]; + void TokenFunc7124(x64Operand &operand, int tokenPos); static x64Token tokenBranches7125[]; static x64Token tokenBranches7126[]; static x64Token tokenBranches7127[]; - static Coding tokenCoding7128_16[]; - static Coding tokenCoding7128_17[]; - static Coding tokenCoding7128_18[]; - static Coding tokenCoding7128_19[]; - void TokenFunc7128(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7129[]; + static x64Token tokenBranches7128[]; + static Coding tokenCoding7129_16[]; + static Coding tokenCoding7129_17[]; + static Coding tokenCoding7129_18[]; + static Coding tokenCoding7129_19[]; + void TokenFunc7129(x64Operand &operand, int tokenPos); static x64Token tokenBranches7130[]; - static Coding tokenCoding7131_16[]; - static Coding tokenCoding7131_17[]; - static Coding tokenCoding7131_18[]; - static Coding tokenCoding7131_19[]; - void TokenFunc7131(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7131[]; + static x64Token tokenBranches7132[]; + static x64Token tokenBranches7133[]; static Coding tokenCoding7134_16[]; static Coding tokenCoding7134_17[]; static Coding tokenCoding7134_18[]; static Coding tokenCoding7134_19[]; void TokenFunc7134(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7135[]; + static x64Token tokenBranches7136[]; static Coding tokenCoding7137_16[]; static Coding tokenCoding7137_17[]; static Coding tokenCoding7137_18[]; static Coding tokenCoding7137_19[]; void TokenFunc7137(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7138[]; - static x64Token tokenBranches7139[]; + static Coding tokenCoding7140_16[]; + static Coding tokenCoding7140_17[]; + static Coding tokenCoding7140_18[]; + static Coding tokenCoding7140_19[]; void TokenFunc7140(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7140[]; - static x64Token tokenBranches7141[]; - static x64Token tokenBranches7142[]; + static Coding tokenCoding7143_16[]; + static Coding tokenCoding7143_17[]; + static Coding tokenCoding7143_18[]; + static Coding tokenCoding7143_19[]; void TokenFunc7143(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7144[]; + static x64Token tokenBranches7145[]; void TokenFunc7146(x64Operand &operand, int tokenPos); static x64Token tokenBranches7146[]; static x64Token tokenBranches7147[]; - void TokenFunc7148(x64Operand &operand, int tokenPos); static x64Token tokenBranches7148[]; - static x64Token tokenBranches7149[]; - static x64Token tokenBranches7150[]; - void TokenFunc7151(x64Operand &operand, int tokenPos); + void TokenFunc7149(x64Operand &operand, int tokenPos); + void TokenFunc7152(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7152[]; + static x64Token tokenBranches7153[]; void TokenFunc7154(x64Operand &operand, int tokenPos); static x64Token tokenBranches7154[]; static x64Token tokenBranches7155[]; static x64Token tokenBranches7156[]; void TokenFunc7157(x64Operand &operand, int tokenPos); - void TokenFunc7162(x64Operand &operand, int tokenPos); + void TokenFunc7160(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7160[]; + static x64Token tokenBranches7161[]; static x64Token tokenBranches7162[]; - static x64Token tokenBranches7163[]; - static x64Token tokenBranches7164[]; - void TokenFunc7165(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7166[]; - static x64Token tokenBranches7167[]; + void TokenFunc7163(x64Operand &operand, int tokenPos); void TokenFunc7168(x64Operand &operand, int tokenPos); static x64Token tokenBranches7168[]; static x64Token tokenBranches7169[]; static x64Token tokenBranches7170[]; void TokenFunc7171(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7172[]; + static x64Token tokenBranches7173[]; void TokenFunc7174(x64Operand &operand, int tokenPos); static x64Token tokenBranches7174[]; static x64Token tokenBranches7175[]; - void TokenFunc7176(x64Operand &operand, int tokenPos); static x64Token tokenBranches7176[]; - static x64Token tokenBranches7177[]; - static x64Token tokenBranches7178[]; - void TokenFunc7179(x64Operand &operand, int tokenPos); + void TokenFunc7177(x64Operand &operand, int tokenPos); + void TokenFunc7180(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7180[]; + static x64Token tokenBranches7181[]; void TokenFunc7182(x64Operand &operand, int tokenPos); static x64Token tokenBranches7182[]; static x64Token tokenBranches7183[]; static x64Token tokenBranches7184[]; void TokenFunc7185(x64Operand &operand, int tokenPos); - void TokenFunc7190(x64Operand &operand, int tokenPos); + void TokenFunc7188(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7188[]; + static x64Token tokenBranches7189[]; static x64Token tokenBranches7190[]; - static x64Token tokenBranches7191[]; - static x64Token tokenBranches7192[]; - void TokenFunc7193(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7194[]; - static x64Token tokenBranches7195[]; + void TokenFunc7191(x64Operand &operand, int tokenPos); void TokenFunc7196(x64Operand &operand, int tokenPos); static x64Token tokenBranches7196[]; static x64Token tokenBranches7197[]; static x64Token tokenBranches7198[]; void TokenFunc7199(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7200[]; + static x64Token tokenBranches7201[]; void TokenFunc7202(x64Operand &operand, int tokenPos); static x64Token tokenBranches7202[]; static x64Token tokenBranches7203[]; - void TokenFunc7204(x64Operand &operand, int tokenPos); static x64Token tokenBranches7204[]; - static x64Token tokenBranches7205[]; - static x64Token tokenBranches7206[]; - void TokenFunc7207(x64Operand &operand, int tokenPos); + void TokenFunc7205(x64Operand &operand, int tokenPos); + void TokenFunc7208(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7208[]; + static x64Token tokenBranches7209[]; void TokenFunc7210(x64Operand &operand, int tokenPos); static x64Token tokenBranches7210[]; static x64Token tokenBranches7211[]; static x64Token tokenBranches7212[]; void TokenFunc7213(x64Operand &operand, int tokenPos); - void TokenFunc7218(x64Operand &operand, int tokenPos); + void TokenFunc7216(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7216[]; + static x64Token tokenBranches7217[]; static x64Token tokenBranches7218[]; - static x64Token tokenBranches7219[]; - static x64Token tokenBranches7220[]; - void TokenFunc7221(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7223[]; + void TokenFunc7219(x64Operand &operand, int tokenPos); + void TokenFunc7224(x64Operand &operand, int tokenPos); static x64Token tokenBranches7224[]; - static Coding tokenCoding7225_16[]; - static Coding tokenCoding7225_17[]; - static Coding tokenCoding7225_18[]; - static Coding tokenCoding7225_19[]; - void TokenFunc7225(x64Operand &operand, int tokenPos); - static Coding tokenCoding7229_16[]; - static Coding tokenCoding7229_17[]; - static Coding tokenCoding7229_23[]; - static Coding tokenCoding7229_18[]; - static Coding tokenCoding7229_19[]; - void TokenFunc7229(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7231[]; - static x64Token tokenBranches7232[]; - static Coding tokenCoding7233_16[]; - static Coding tokenCoding7233_17[]; - static Coding tokenCoding7233_18[]; - static Coding tokenCoding7233_19[]; - void TokenFunc7233(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7235[]; - static x64Token tokenBranches7236[]; - static Coding tokenCoding7237_16[]; - static Coding tokenCoding7237_17[]; - static Coding tokenCoding7237_18[]; - static Coding tokenCoding7237_19[]; - void TokenFunc7237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7225[]; + static x64Token tokenBranches7226[]; + void TokenFunc7227(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7229[]; + static x64Token tokenBranches7230[]; + static Coding tokenCoding7231_16[]; + static Coding tokenCoding7231_17[]; + static Coding tokenCoding7231_18[]; + static Coding tokenCoding7231_19[]; + void TokenFunc7231(x64Operand &operand, int tokenPos); + static Coding tokenCoding7235_16[]; + static Coding tokenCoding7235_17[]; + static Coding tokenCoding7235_23[]; + static Coding tokenCoding7235_18[]; + static Coding tokenCoding7235_19[]; + void TokenFunc7235(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7237[]; static x64Token tokenBranches7238[]; - static x64Token tokenBranches7239[]; - static x64Token tokenBranches7240[]; - static Coding tokenCoding7241_16[]; - static Coding tokenCoding7241_17[]; - static Coding tokenCoding7241_18[]; - static Coding tokenCoding7241_19[]; - void TokenFunc7241(x64Operand &operand, int tokenPos); - void TokenFunc7242(x64Operand &operand, int tokenPos); + static Coding tokenCoding7239_16[]; + static Coding tokenCoding7239_17[]; + static Coding tokenCoding7239_18[]; + static Coding tokenCoding7239_19[]; + void TokenFunc7239(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7241[]; static x64Token tokenBranches7242[]; - static x64Token tokenBranches7243[]; + static Coding tokenCoding7243_16[]; + static Coding tokenCoding7243_17[]; + static Coding tokenCoding7243_18[]; + static Coding tokenCoding7243_19[]; + void TokenFunc7243(x64Operand &operand, int tokenPos); static x64Token tokenBranches7244[]; - static Coding tokenCoding7245_16[]; - static Coding tokenCoding7245_17[]; - static Coding tokenCoding7245_18[]; - static Coding tokenCoding7245_19[]; - void TokenFunc7245(x64Operand &operand, int tokenPos); - static Coding tokenCoding7248_16[]; - static Coding tokenCoding7248_17[]; - static Coding tokenCoding7248_18[]; - static Coding tokenCoding7248_19[]; + static x64Token tokenBranches7245[]; + static x64Token tokenBranches7246[]; + static Coding tokenCoding7247_16[]; + static Coding tokenCoding7247_17[]; + static Coding tokenCoding7247_18[]; + static Coding tokenCoding7247_19[]; + void TokenFunc7247(x64Operand &operand, int tokenPos); void TokenFunc7248(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7248[]; + static x64Token tokenBranches7249[]; + static x64Token tokenBranches7250[]; static Coding tokenCoding7251_16[]; static Coding tokenCoding7251_17[]; static Coding tokenCoding7251_18[]; @@ -4720,18 +4724,16 @@ class x64Parser : public InstructionParser static Coding tokenCoding7254_18[]; static Coding tokenCoding7254_19[]; void TokenFunc7254(x64Operand &operand, int tokenPos); - static Coding tokenCoding7258_16[]; - static Coding tokenCoding7258_17[]; - static Coding tokenCoding7258_18[]; - static Coding tokenCoding7258_19[]; - void TokenFunc7258(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7259[]; - static x64Token tokenBranches7260[]; - static Coding tokenCoding7261_16[]; - static Coding tokenCoding7261_17[]; - static Coding tokenCoding7261_18[]; - static Coding tokenCoding7261_19[]; - void TokenFunc7261(x64Operand &operand, int tokenPos); + static Coding tokenCoding7257_16[]; + static Coding tokenCoding7257_17[]; + static Coding tokenCoding7257_18[]; + static Coding tokenCoding7257_19[]; + void TokenFunc7257(x64Operand &operand, int tokenPos); + static Coding tokenCoding7260_16[]; + static Coding tokenCoding7260_17[]; + static Coding tokenCoding7260_18[]; + static Coding tokenCoding7260_19[]; + void TokenFunc7260(x64Operand &operand, int tokenPos); static Coding tokenCoding7264_16[]; static Coding tokenCoding7264_17[]; static Coding tokenCoding7264_18[]; @@ -4744,30 +4746,36 @@ class x64Parser : public InstructionParser static Coding tokenCoding7267_18[]; static Coding tokenCoding7267_19[]; void TokenFunc7267(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7268[]; - static x64Token tokenBranches7269[]; - static x64Token tokenBranches7270[]; - static Coding tokenCoding7271_18[]; - static Coding tokenCoding7271_19[]; - void TokenFunc7271(x64Operand &operand, int tokenPos); + static Coding tokenCoding7270_16[]; + static Coding tokenCoding7270_17[]; + static Coding tokenCoding7270_18[]; + static Coding tokenCoding7270_19[]; + void TokenFunc7270(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7271[]; + static x64Token tokenBranches7272[]; + static Coding tokenCoding7273_16[]; + static Coding tokenCoding7273_17[]; + static Coding tokenCoding7273_18[]; + static Coding tokenCoding7273_19[]; + void TokenFunc7273(x64Operand &operand, int tokenPos); static x64Token tokenBranches7274[]; - static Coding tokenCoding7275_18[]; - static Coding tokenCoding7275_19[]; - void TokenFunc7275(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7278[]; - static Coding tokenCoding7279_18[]; - static Coding tokenCoding7279_19[]; - void TokenFunc7279(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7282[]; - static Coding tokenCoding7283_18[]; - static Coding tokenCoding7283_19[]; - void TokenFunc7283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7275[]; + static x64Token tokenBranches7276[]; + static Coding tokenCoding7277_18[]; + static Coding tokenCoding7277_19[]; + void TokenFunc7277(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7280[]; + static Coding tokenCoding7281_18[]; + static Coding tokenCoding7281_19[]; + void TokenFunc7281(x64Operand &operand, int tokenPos); static x64Token tokenBranches7284[]; - static x64Token tokenBranches7285[]; - static x64Token tokenBranches7286[]; - static x64Token tokenBranches7287[]; + static Coding tokenCoding7285_18[]; + static Coding tokenCoding7285_19[]; + void TokenFunc7285(x64Operand &operand, int tokenPos); static x64Token tokenBranches7288[]; - static x64Token tokenBranches7289[]; + static Coding tokenCoding7289_18[]; + static Coding tokenCoding7289_19[]; + void TokenFunc7289(x64Operand &operand, int tokenPos); static x64Token tokenBranches7290[]; static x64Token tokenBranches7291[]; static x64Token tokenBranches7292[]; @@ -4775,398 +4783,380 @@ class x64Parser : public InstructionParser static x64Token tokenBranches7294[]; static x64Token tokenBranches7295[]; static x64Token tokenBranches7296[]; - void TokenFunc7297(x64Operand &operand, int tokenPos); - void TokenFunc7307(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7307[]; - static x64Token tokenBranches7308[]; - static x64Token tokenBranches7309[]; - void TokenFunc7310(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7297[]; + static x64Token tokenBranches7298[]; + static x64Token tokenBranches7299[]; + static x64Token tokenBranches7300[]; + static x64Token tokenBranches7301[]; + static x64Token tokenBranches7302[]; + void TokenFunc7303(x64Operand &operand, int tokenPos); + void TokenFunc7313(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7313[]; + static x64Token tokenBranches7314[]; static x64Token tokenBranches7315[]; - static x64Token tokenBranches7316[]; - static x64Token tokenBranches7317[]; - static x64Token tokenBranches7318[]; - static x64Token tokenBranches7319[]; - static x64Token tokenBranches7320[]; + void TokenFunc7316(x64Operand &operand, int tokenPos); static x64Token tokenBranches7321[]; static x64Token tokenBranches7322[]; - void TokenFunc7323(x64Operand &operand, int tokenPos); - void TokenFunc7333(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7333[]; - static x64Token tokenBranches7334[]; - static x64Token tokenBranches7335[]; - void TokenFunc7336(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7338[]; + static x64Token tokenBranches7323[]; + static x64Token tokenBranches7324[]; + static x64Token tokenBranches7325[]; + static x64Token tokenBranches7326[]; + static x64Token tokenBranches7327[]; + static x64Token tokenBranches7328[]; + void TokenFunc7329(x64Operand &operand, int tokenPos); + void TokenFunc7339(x64Operand &operand, int tokenPos); static x64Token tokenBranches7339[]; static x64Token tokenBranches7340[]; static x64Token tokenBranches7341[]; - static x64Token tokenBranches7342[]; - static x64Token tokenBranches7343[]; + void TokenFunc7342(x64Operand &operand, int tokenPos); static x64Token tokenBranches7344[]; - void TokenFunc7345(x64Operand &operand, int tokenPos); - void TokenFunc7353(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7353[]; - static x64Token tokenBranches7354[]; - static x64Token tokenBranches7355[]; - void TokenFunc7356(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7357[]; - static x64Token tokenBranches7358[]; + static x64Token tokenBranches7345[]; + static x64Token tokenBranches7346[]; + static x64Token tokenBranches7347[]; + static x64Token tokenBranches7348[]; + static x64Token tokenBranches7349[]; + static x64Token tokenBranches7350[]; + void TokenFunc7351(x64Operand &operand, int tokenPos); + void TokenFunc7359(x64Operand &operand, int tokenPos); static x64Token tokenBranches7359[]; static x64Token tokenBranches7360[]; static x64Token tokenBranches7361[]; - static x64Token tokenBranches7362[]; + void TokenFunc7362(x64Operand &operand, int tokenPos); static x64Token tokenBranches7363[]; static x64Token tokenBranches7364[]; static x64Token tokenBranches7365[]; static x64Token tokenBranches7366[]; static x64Token tokenBranches7367[]; static x64Token tokenBranches7368[]; - void TokenFunc7369(x64Operand &operand, int tokenPos); - void TokenFunc7379(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7379[]; - static x64Token tokenBranches7380[]; - static x64Token tokenBranches7381[]; - void TokenFunc7382(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7369[]; + static x64Token tokenBranches7370[]; + static x64Token tokenBranches7371[]; + static x64Token tokenBranches7372[]; + static x64Token tokenBranches7373[]; + static x64Token tokenBranches7374[]; + void TokenFunc7375(x64Operand &operand, int tokenPos); + void TokenFunc7385(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7385[]; + static x64Token tokenBranches7386[]; static x64Token tokenBranches7387[]; - static x64Token tokenBranches7388[]; - static x64Token tokenBranches7389[]; - static x64Token tokenBranches7390[]; - static x64Token tokenBranches7391[]; - static x64Token tokenBranches7392[]; + void TokenFunc7388(x64Operand &operand, int tokenPos); static x64Token tokenBranches7393[]; static x64Token tokenBranches7394[]; - void TokenFunc7395(x64Operand &operand, int tokenPos); - void TokenFunc7405(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7405[]; - static x64Token tokenBranches7406[]; - static x64Token tokenBranches7407[]; - void TokenFunc7408(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7410[]; + static x64Token tokenBranches7395[]; + static x64Token tokenBranches7396[]; + static x64Token tokenBranches7397[]; + static x64Token tokenBranches7398[]; + static x64Token tokenBranches7399[]; + static x64Token tokenBranches7400[]; + void TokenFunc7401(x64Operand &operand, int tokenPos); + void TokenFunc7411(x64Operand &operand, int tokenPos); static x64Token tokenBranches7411[]; static x64Token tokenBranches7412[]; static x64Token tokenBranches7413[]; - static x64Token tokenBranches7414[]; - static x64Token tokenBranches7415[]; + void TokenFunc7414(x64Operand &operand, int tokenPos); static x64Token tokenBranches7416[]; - void TokenFunc7417(x64Operand &operand, int tokenPos); - void TokenFunc7425(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7425[]; - static x64Token tokenBranches7426[]; - static x64Token tokenBranches7427[]; - void TokenFunc7428(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7429[]; - static x64Token tokenBranches7430[]; + static x64Token tokenBranches7417[]; + static x64Token tokenBranches7418[]; + static x64Token tokenBranches7419[]; + static x64Token tokenBranches7420[]; + static x64Token tokenBranches7421[]; + static x64Token tokenBranches7422[]; + void TokenFunc7423(x64Operand &operand, int tokenPos); + void TokenFunc7431(x64Operand &operand, int tokenPos); static x64Token tokenBranches7431[]; static x64Token tokenBranches7432[]; static x64Token tokenBranches7433[]; - static x64Token tokenBranches7434[]; + void TokenFunc7434(x64Operand &operand, int tokenPos); static x64Token tokenBranches7435[]; static x64Token tokenBranches7436[]; static x64Token tokenBranches7437[]; static x64Token tokenBranches7438[]; static x64Token tokenBranches7439[]; static x64Token tokenBranches7440[]; - void TokenFunc7441(x64Operand &operand, int tokenPos); - void TokenFunc7451(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7451[]; - static x64Token tokenBranches7452[]; - static x64Token tokenBranches7453[]; - void TokenFunc7454(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7441[]; + static x64Token tokenBranches7442[]; + static x64Token tokenBranches7443[]; + static x64Token tokenBranches7444[]; + static x64Token tokenBranches7445[]; + static x64Token tokenBranches7446[]; + void TokenFunc7447(x64Operand &operand, int tokenPos); + void TokenFunc7457(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7457[]; + static x64Token tokenBranches7458[]; static x64Token tokenBranches7459[]; - static x64Token tokenBranches7460[]; - static x64Token tokenBranches7461[]; - static x64Token tokenBranches7462[]; - static x64Token tokenBranches7463[]; - static x64Token tokenBranches7464[]; + void TokenFunc7460(x64Operand &operand, int tokenPos); static x64Token tokenBranches7465[]; static x64Token tokenBranches7466[]; - void TokenFunc7467(x64Operand &operand, int tokenPos); - void TokenFunc7477(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7477[]; - static x64Token tokenBranches7478[]; - static x64Token tokenBranches7479[]; - void TokenFunc7480(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7482[]; + static x64Token tokenBranches7467[]; + static x64Token tokenBranches7468[]; + static x64Token tokenBranches7469[]; + static x64Token tokenBranches7470[]; + static x64Token tokenBranches7471[]; + static x64Token tokenBranches7472[]; + void TokenFunc7473(x64Operand &operand, int tokenPos); + void TokenFunc7483(x64Operand &operand, int tokenPos); static x64Token tokenBranches7483[]; static x64Token tokenBranches7484[]; static x64Token tokenBranches7485[]; - static x64Token tokenBranches7486[]; - static x64Token tokenBranches7487[]; + void TokenFunc7486(x64Operand &operand, int tokenPos); static x64Token tokenBranches7488[]; - void TokenFunc7489(x64Operand &operand, int tokenPos); - void TokenFunc7497(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7497[]; - static x64Token tokenBranches7498[]; - static x64Token tokenBranches7499[]; - void TokenFunc7500(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7501[]; - static x64Token tokenBranches7502[]; + static x64Token tokenBranches7489[]; + static x64Token tokenBranches7490[]; + static x64Token tokenBranches7491[]; + static x64Token tokenBranches7492[]; + static x64Token tokenBranches7493[]; + static x64Token tokenBranches7494[]; + void TokenFunc7495(x64Operand &operand, int tokenPos); + void TokenFunc7503(x64Operand &operand, int tokenPos); static x64Token tokenBranches7503[]; static x64Token tokenBranches7504[]; static x64Token tokenBranches7505[]; - static x64Token tokenBranches7506[]; + void TokenFunc7506(x64Operand &operand, int tokenPos); static x64Token tokenBranches7507[]; static x64Token tokenBranches7508[]; static x64Token tokenBranches7509[]; static x64Token tokenBranches7510[]; static x64Token tokenBranches7511[]; static x64Token tokenBranches7512[]; - void TokenFunc7513(x64Operand &operand, int tokenPos); - void TokenFunc7523(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7523[]; - static x64Token tokenBranches7524[]; - static x64Token tokenBranches7525[]; - void TokenFunc7526(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7528[]; + static x64Token tokenBranches7513[]; + static x64Token tokenBranches7514[]; + static x64Token tokenBranches7515[]; + static x64Token tokenBranches7516[]; + static x64Token tokenBranches7517[]; + static x64Token tokenBranches7518[]; + void TokenFunc7519(x64Operand &operand, int tokenPos); + void TokenFunc7529(x64Operand &operand, int tokenPos); static x64Token tokenBranches7529[]; static x64Token tokenBranches7530[]; static x64Token tokenBranches7531[]; - static x64Token tokenBranches7532[]; - static x64Token tokenBranches7533[]; + void TokenFunc7532(x64Operand &operand, int tokenPos); static x64Token tokenBranches7534[]; - void TokenFunc7535(x64Operand &operand, int tokenPos); - void TokenFunc7543(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7543[]; - static x64Token tokenBranches7544[]; - static x64Token tokenBranches7545[]; - void TokenFunc7546(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7547[]; - void TokenFunc7548(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7548[]; + static x64Token tokenBranches7535[]; + static x64Token tokenBranches7536[]; + static x64Token tokenBranches7537[]; + static x64Token tokenBranches7538[]; + static x64Token tokenBranches7539[]; + static x64Token tokenBranches7540[]; + void TokenFunc7541(x64Operand &operand, int tokenPos); + void TokenFunc7549(x64Operand &operand, int tokenPos); static x64Token tokenBranches7549[]; static x64Token tokenBranches7550[]; - static Coding tokenCoding7551_16[]; - static Coding tokenCoding7551_17[]; - static Coding tokenCoding7551_18[]; - static Coding tokenCoding7551_19[]; - void TokenFunc7551(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7551[]; void TokenFunc7552(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7552[]; static x64Token tokenBranches7553[]; + void TokenFunc7554(x64Operand &operand, int tokenPos); static x64Token tokenBranches7554[]; - static Coding tokenCoding7555_16[]; - static Coding tokenCoding7555_17[]; - static Coding tokenCoding7555_18[]; - static Coding tokenCoding7555_19[]; - void TokenFunc7555(x64Operand &operand, int tokenPos); - void TokenFunc7556(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7555[]; static x64Token tokenBranches7556[]; - static x64Token tokenBranches7557[]; + static Coding tokenCoding7557_16[]; + static Coding tokenCoding7557_17[]; + static Coding tokenCoding7557_18[]; + static Coding tokenCoding7557_19[]; + void TokenFunc7557(x64Operand &operand, int tokenPos); + void TokenFunc7558(x64Operand &operand, int tokenPos); static x64Token tokenBranches7558[]; - static Coding tokenCoding7559_16[]; - static Coding tokenCoding7559_17[]; - static Coding tokenCoding7559_18[]; - static Coding tokenCoding7559_19[]; - void TokenFunc7559(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7559[]; static x64Token tokenBranches7560[]; - static x64Token tokenBranches7561[]; + static Coding tokenCoding7561_16[]; + static Coding tokenCoding7561_17[]; + static Coding tokenCoding7561_18[]; + static Coding tokenCoding7561_19[]; + void TokenFunc7561(x64Operand &operand, int tokenPos); + void TokenFunc7562(x64Operand &operand, int tokenPos); static x64Token tokenBranches7562[]; - static Coding tokenCoding7563_16[]; - static Coding tokenCoding7563_17[]; - static Coding tokenCoding7563_18[]; - static Coding tokenCoding7563_19[]; - void TokenFunc7563(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7563[]; static x64Token tokenBranches7564[]; - static x64Token tokenBranches7565[]; + static Coding tokenCoding7565_16[]; + static Coding tokenCoding7565_17[]; + static Coding tokenCoding7565_18[]; + static Coding tokenCoding7565_19[]; + void TokenFunc7565(x64Operand &operand, int tokenPos); static x64Token tokenBranches7566[]; - static Coding tokenCoding7567_16[]; - static Coding tokenCoding7567_17[]; - static Coding tokenCoding7567_18[]; - static Coding tokenCoding7567_19[]; - void TokenFunc7567(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7567[]; static x64Token tokenBranches7568[]; - static x64Token tokenBranches7569[]; + static Coding tokenCoding7569_16[]; + static Coding tokenCoding7569_17[]; + static Coding tokenCoding7569_18[]; + static Coding tokenCoding7569_19[]; + void TokenFunc7569(x64Operand &operand, int tokenPos); static x64Token tokenBranches7570[]; - static Coding tokenCoding7571_16[]; - static Coding tokenCoding7571_17[]; - static Coding tokenCoding7571_18[]; - static Coding tokenCoding7571_19[]; - void TokenFunc7571(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7571[]; + static x64Token tokenBranches7572[]; + static Coding tokenCoding7573_16[]; + static Coding tokenCoding7573_17[]; + static Coding tokenCoding7573_18[]; + static Coding tokenCoding7573_19[]; + void TokenFunc7573(x64Operand &operand, int tokenPos); static x64Token tokenBranches7574[]; - void TokenFunc7575(x64Operand &operand, int tokenPos); static x64Token tokenBranches7575[]; static x64Token tokenBranches7576[]; static Coding tokenCoding7577_16[]; static Coding tokenCoding7577_17[]; - static Coding tokenCoding7577_23[]; static Coding tokenCoding7577_18[]; static Coding tokenCoding7577_19[]; void TokenFunc7577(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7578[]; - static x64Token tokenBranches7579[]; - static Coding tokenCoding7580_16[]; - static Coding tokenCoding7580_17[]; - static Coding tokenCoding7580_23[]; - static Coding tokenCoding7580_18[]; - static Coding tokenCoding7580_19[]; - void TokenFunc7580(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7580[]; void TokenFunc7581(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7581[]; static x64Token tokenBranches7582[]; + static Coding tokenCoding7583_16[]; + static Coding tokenCoding7583_17[]; + static Coding tokenCoding7583_23[]; + static Coding tokenCoding7583_18[]; + static Coding tokenCoding7583_19[]; void TokenFunc7583(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7586[]; + static x64Token tokenBranches7584[]; + static x64Token tokenBranches7585[]; + static Coding tokenCoding7586_16[]; + static Coding tokenCoding7586_17[]; + static Coding tokenCoding7586_23[]; + static Coding tokenCoding7586_18[]; + static Coding tokenCoding7586_19[]; + void TokenFunc7586(x64Operand &operand, int tokenPos); void TokenFunc7587(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7587[]; static x64Token tokenBranches7588[]; - static Coding tokenCoding7589_16[]; - static Coding tokenCoding7589_17[]; - static Coding tokenCoding7589_18[]; - static Coding tokenCoding7589_19[]; void TokenFunc7589(x64Operand &operand, int tokenPos); static x64Token tokenBranches7592[]; - static Coding tokenCoding7593_16[]; - static Coding tokenCoding7593_17[]; - static Coding tokenCoding7593_18[]; - static Coding tokenCoding7593_19[]; void TokenFunc7593(x64Operand &operand, int tokenPos); - void TokenFunc7594(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7593[]; static x64Token tokenBranches7594[]; - static x64Token tokenBranches7595[]; - static Coding tokenCoding7596_16[]; - static Coding tokenCoding7596_17[]; - static Coding tokenCoding7596_18[]; - static Coding tokenCoding7596_19[]; - void TokenFunc7596(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7599[]; - static Coding tokenCoding7600_16[]; - static Coding tokenCoding7600_17[]; - static Coding tokenCoding7600_18[]; - static Coding tokenCoding7600_19[]; + static Coding tokenCoding7595_16[]; + static Coding tokenCoding7595_17[]; + static Coding tokenCoding7595_18[]; + static Coding tokenCoding7595_19[]; + void TokenFunc7595(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7598[]; + static Coding tokenCoding7599_16[]; + static Coding tokenCoding7599_17[]; + static Coding tokenCoding7599_18[]; + static Coding tokenCoding7599_19[]; + void TokenFunc7599(x64Operand &operand, int tokenPos); void TokenFunc7600(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7606[]; - static x64Token tokenBranches7607[]; - void TokenFunc7608(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7608[]; - static x64Token tokenBranches7609[]; - void TokenFunc7610(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7611[]; - void TokenFunc7612(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7600[]; + static x64Token tokenBranches7601[]; + static Coding tokenCoding7602_16[]; + static Coding tokenCoding7602_17[]; + static Coding tokenCoding7602_18[]; + static Coding tokenCoding7602_19[]; + void TokenFunc7602(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7605[]; + static Coding tokenCoding7606_16[]; + static Coding tokenCoding7606_17[]; + static Coding tokenCoding7606_18[]; + static Coding tokenCoding7606_19[]; + void TokenFunc7606(x64Operand &operand, int tokenPos); static x64Token tokenBranches7612[]; static x64Token tokenBranches7613[]; void TokenFunc7614(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7614[]; static x64Token tokenBranches7615[]; void TokenFunc7616(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7616[]; static x64Token tokenBranches7617[]; void TokenFunc7618(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7618[]; static x64Token tokenBranches7619[]; void TokenFunc7620(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7620[]; static x64Token tokenBranches7621[]; void TokenFunc7622(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7622[]; static x64Token tokenBranches7623[]; - static x64Token tokenBranches7624[]; - void TokenFunc7625(x64Operand &operand, int tokenPos); + void TokenFunc7624(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7625[]; + void TokenFunc7626(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7626[]; + static x64Token tokenBranches7627[]; void TokenFunc7628(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7629[]; + static x64Token tokenBranches7630[]; void TokenFunc7631(x64Operand &operand, int tokenPos); void TokenFunc7634(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7635[]; - static x64Token tokenBranches7636[]; - static x64Token tokenBranches7637[]; - static x64Token tokenBranches7638[]; - static x64Token tokenBranches7639[]; - static x64Token tokenBranches7640[]; + void TokenFunc7637(x64Operand &operand, int tokenPos); + void TokenFunc7640(x64Operand &operand, int tokenPos); static x64Token tokenBranches7641[]; static x64Token tokenBranches7642[]; - void TokenFunc7643(x64Operand &operand, int tokenPos); - void TokenFunc7648(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7643[]; + static x64Token tokenBranches7644[]; + static x64Token tokenBranches7645[]; + static x64Token tokenBranches7646[]; + static x64Token tokenBranches7647[]; static x64Token tokenBranches7648[]; - static x64Token tokenBranches7649[]; - static x64Token tokenBranches7650[]; - void TokenFunc7651(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7658[]; - void TokenFunc7659(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7666[]; - void TokenFunc7667(x64Operand &operand, int tokenPos); + void TokenFunc7649(x64Operand &operand, int tokenPos); + void TokenFunc7654(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7654[]; + static x64Token tokenBranches7655[]; + static x64Token tokenBranches7656[]; + void TokenFunc7657(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7664[]; + void TokenFunc7665(x64Operand &operand, int tokenPos); static x64Token tokenBranches7672[]; void TokenFunc7673(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7680[]; - void TokenFunc7681(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7684[]; - static x64Token tokenBranches7685[]; + static x64Token tokenBranches7678[]; + void TokenFunc7679(x64Operand &operand, int tokenPos); static x64Token tokenBranches7686[]; - static x64Token tokenBranches7687[]; - static x64Token tokenBranches7688[]; - void TokenFunc7689(x64Operand &operand, int tokenPos); - void TokenFunc7694(x64Operand &operand, int tokenPos); + void TokenFunc7687(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7690[]; + static x64Token tokenBranches7691[]; + static x64Token tokenBranches7692[]; + static x64Token tokenBranches7693[]; static x64Token tokenBranches7694[]; - static x64Token tokenBranches7695[]; - static x64Token tokenBranches7696[]; - void TokenFunc7697(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7704[]; - void TokenFunc7705(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7712[]; - void TokenFunc7713(x64Operand &operand, int tokenPos); + void TokenFunc7695(x64Operand &operand, int tokenPos); + void TokenFunc7700(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7700[]; + static x64Token tokenBranches7701[]; + static x64Token tokenBranches7702[]; + void TokenFunc7703(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7710[]; + void TokenFunc7711(x64Operand &operand, int tokenPos); static x64Token tokenBranches7718[]; void TokenFunc7719(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7726[]; - void TokenFunc7727(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7730[]; - static x64Token tokenBranches7731[]; + static x64Token tokenBranches7724[]; + void TokenFunc7725(x64Operand &operand, int tokenPos); static x64Token tokenBranches7732[]; - static x64Token tokenBranches7733[]; - static x64Token tokenBranches7734[]; - void TokenFunc7735(x64Operand &operand, int tokenPos); - void TokenFunc7740(x64Operand &operand, int tokenPos); + void TokenFunc7733(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7736[]; + static x64Token tokenBranches7737[]; + static x64Token tokenBranches7738[]; + static x64Token tokenBranches7739[]; static x64Token tokenBranches7740[]; - static x64Token tokenBranches7741[]; - static x64Token tokenBranches7742[]; - void TokenFunc7743(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7750[]; - void TokenFunc7751(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7758[]; - void TokenFunc7759(x64Operand &operand, int tokenPos); + void TokenFunc7741(x64Operand &operand, int tokenPos); + void TokenFunc7746(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7746[]; + static x64Token tokenBranches7747[]; + static x64Token tokenBranches7748[]; + void TokenFunc7749(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7756[]; + void TokenFunc7757(x64Operand &operand, int tokenPos); static x64Token tokenBranches7764[]; void TokenFunc7765(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7772[]; - void TokenFunc7773(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7777[]; - void TokenFunc7778(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7770[]; + void TokenFunc7771(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7778[]; void TokenFunc7779(x64Operand &operand, int tokenPos); - void TokenFunc7780(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7781[]; - static Coding tokenCoding7782_16[]; - static Coding tokenCoding7782_17[]; - static Coding tokenCoding7782_18[]; - static Coding tokenCoding7782_19[]; - void TokenFunc7782(x64Operand &operand, int tokenPos); static x64Token tokenBranches7783[]; - static Coding tokenCoding7784_16[]; - static Coding tokenCoding7784_17[]; - static Coding tokenCoding7784_18[]; - static Coding tokenCoding7784_19[]; void TokenFunc7784(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7785[]; - static Coding tokenCoding7786_16[]; - static Coding tokenCoding7786_17[]; - static Coding tokenCoding7786_18[]; - static Coding tokenCoding7786_19[]; + void TokenFunc7785(x64Operand &operand, int tokenPos); void TokenFunc7786(x64Operand &operand, int tokenPos); - void TokenFunc7787(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7787[]; + static Coding tokenCoding7788_16[]; + static Coding tokenCoding7788_17[]; + static Coding tokenCoding7788_18[]; + static Coding tokenCoding7788_19[]; void TokenFunc7788(x64Operand &operand, int tokenPos); - void TokenFunc7789(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7798[]; - static Coding tokenCoding7799_34[]; - static Coding tokenCoding7799_16[]; - static Coding tokenCoding7799_17[]; - static Coding tokenCoding7799_35[]; - static Coding tokenCoding7799_18[]; - static Coding tokenCoding7799_19[]; - void TokenFunc7799(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7800[]; - static Coding tokenCoding7801_34[]; - static Coding tokenCoding7801_16[]; - static Coding tokenCoding7801_17[]; - static Coding tokenCoding7801_35[]; - static Coding tokenCoding7801_18[]; - static Coding tokenCoding7801_19[]; - void TokenFunc7801(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7802[]; - static Coding tokenCoding7803_34[]; - static Coding tokenCoding7803_16[]; - static Coding tokenCoding7803_17[]; - static Coding tokenCoding7803_35[]; - static Coding tokenCoding7803_18[]; - static Coding tokenCoding7803_19[]; - void TokenFunc7803(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7789[]; + static Coding tokenCoding7790_16[]; + static Coding tokenCoding7790_17[]; + static Coding tokenCoding7790_18[]; + static Coding tokenCoding7790_19[]; + void TokenFunc7790(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7791[]; + static Coding tokenCoding7792_16[]; + static Coding tokenCoding7792_17[]; + static Coding tokenCoding7792_18[]; + static Coding tokenCoding7792_19[]; + void TokenFunc7792(x64Operand &operand, int tokenPos); + void TokenFunc7793(x64Operand &operand, int tokenPos); + void TokenFunc7794(x64Operand &operand, int tokenPos); + void TokenFunc7795(x64Operand &operand, int tokenPos); static x64Token tokenBranches7804[]; static Coding tokenCoding7805_34[]; static Coding tokenCoding7805_16[]; @@ -5176,317 +5166,327 @@ class x64Parser : public InstructionParser static Coding tokenCoding7805_19[]; void TokenFunc7805(x64Operand &operand, int tokenPos); static x64Token tokenBranches7806[]; + static Coding tokenCoding7807_34[]; + static Coding tokenCoding7807_16[]; + static Coding tokenCoding7807_17[]; + static Coding tokenCoding7807_35[]; + static Coding tokenCoding7807_18[]; + static Coding tokenCoding7807_19[]; void TokenFunc7807(x64Operand &operand, int tokenPos); - void TokenFunc7808(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7808[]; + static Coding tokenCoding7809_34[]; + static Coding tokenCoding7809_16[]; + static Coding tokenCoding7809_17[]; + static Coding tokenCoding7809_35[]; + static Coding tokenCoding7809_18[]; + static Coding tokenCoding7809_19[]; void TokenFunc7809(x64Operand &operand, int tokenPos); static x64Token tokenBranches7810[]; + static Coding tokenCoding7811_34[]; + static Coding tokenCoding7811_16[]; + static Coding tokenCoding7811_17[]; + static Coding tokenCoding7811_35[]; + static Coding tokenCoding7811_18[]; + static Coding tokenCoding7811_19[]; void TokenFunc7811(x64Operand &operand, int tokenPos); - void TokenFunc7812(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7812[]; void TokenFunc7813(x64Operand &operand, int tokenPos); void TokenFunc7814(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7815[]; - void TokenFunc7816(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7817[]; + void TokenFunc7815(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7816[]; + void TokenFunc7817(x64Operand &operand, int tokenPos); void TokenFunc7818(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7819[]; + void TokenFunc7819(x64Operand &operand, int tokenPos); void TokenFunc7820(x64Operand &operand, int tokenPos); - static Coding tokenCoding7822_16[]; - static Coding tokenCoding7822_17[]; - static Coding tokenCoding7822_18[]; - static Coding tokenCoding7822_19[]; + static x64Token tokenBranches7821[]; void TokenFunc7822(x64Operand &operand, int tokenPos); - static Coding tokenCoding7824_16[]; - static Coding tokenCoding7824_17[]; - static Coding tokenCoding7824_18[]; - static Coding tokenCoding7824_19[]; + static x64Token tokenBranches7823[]; void TokenFunc7824(x64Operand &operand, int tokenPos); - static Coding tokenCoding7826_16[]; - static Coding tokenCoding7826_17[]; - static Coding tokenCoding7826_18[]; - static Coding tokenCoding7826_19[]; + static x64Token tokenBranches7825[]; void TokenFunc7826(x64Operand &operand, int tokenPos); - void TokenFunc7827(x64Operand &operand, int tokenPos); + static Coding tokenCoding7828_16[]; + static Coding tokenCoding7828_17[]; + static Coding tokenCoding7828_18[]; + static Coding tokenCoding7828_19[]; void TokenFunc7828(x64Operand &operand, int tokenPos); - void TokenFunc7829(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7842[]; - void TokenFunc7843(x64Operand &operand, int tokenPos); - void TokenFunc7844(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7845[]; - void TokenFunc7846(x64Operand &operand, int tokenPos); - void TokenFunc7847(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7855[]; - static x64Token tokenBranches7856[]; - static x64Token tokenBranches7857[]; - static x64Token tokenBranches7858[]; - static x64Token tokenBranches7859[]; - static x64Token tokenBranches7860[]; - void TokenFunc7861(x64Operand &operand, int tokenPos); + static Coding tokenCoding7830_16[]; + static Coding tokenCoding7830_17[]; + static Coding tokenCoding7830_18[]; + static Coding tokenCoding7830_19[]; + void TokenFunc7830(x64Operand &operand, int tokenPos); + static Coding tokenCoding7832_16[]; + static Coding tokenCoding7832_17[]; + static Coding tokenCoding7832_18[]; + static Coding tokenCoding7832_19[]; + void TokenFunc7832(x64Operand &operand, int tokenPos); + void TokenFunc7833(x64Operand &operand, int tokenPos); + void TokenFunc7834(x64Operand &operand, int tokenPos); + void TokenFunc7835(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7848[]; + void TokenFunc7849(x64Operand &operand, int tokenPos); + void TokenFunc7850(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7851[]; + void TokenFunc7852(x64Operand &operand, int tokenPos); + void TokenFunc7853(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7861[]; + static x64Token tokenBranches7862[]; static x64Token tokenBranches7863[]; - void TokenFunc7864(x64Operand &operand, int tokenPos); static x64Token tokenBranches7864[]; static x64Token tokenBranches7865[]; static x64Token tokenBranches7866[]; void TokenFunc7867(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7869[]; + void TokenFunc7870(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7870[]; + static x64Token tokenBranches7871[]; static x64Token tokenBranches7872[]; void TokenFunc7873(x64Operand &operand, int tokenPos); static x64Token tokenBranches7878[]; void TokenFunc7879(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7882[]; - void TokenFunc7883(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7884[]; + void TokenFunc7885(x64Operand &operand, int tokenPos); static x64Token tokenBranches7888[]; void TokenFunc7889(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7890[]; - static x64Token tokenBranches7891[]; - static x64Token tokenBranches7892[]; - static x64Token tokenBranches7893[]; static x64Token tokenBranches7894[]; void TokenFunc7895(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7896[]; static x64Token tokenBranches7897[]; - void TokenFunc7898(x64Operand &operand, int tokenPos); static x64Token tokenBranches7898[]; static x64Token tokenBranches7899[]; static x64Token tokenBranches7900[]; void TokenFunc7901(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7903[]; + void TokenFunc7904(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7904[]; + static x64Token tokenBranches7905[]; static x64Token tokenBranches7906[]; void TokenFunc7907(x64Operand &operand, int tokenPos); static x64Token tokenBranches7912[]; void TokenFunc7913(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7916[]; - void TokenFunc7917(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7918[]; + void TokenFunc7919(x64Operand &operand, int tokenPos); static x64Token tokenBranches7922[]; void TokenFunc7923(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7924[]; - static x64Token tokenBranches7925[]; - static x64Token tokenBranches7926[]; - static x64Token tokenBranches7927[]; static x64Token tokenBranches7928[]; void TokenFunc7929(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7930[]; static x64Token tokenBranches7931[]; - void TokenFunc7932(x64Operand &operand, int tokenPos); static x64Token tokenBranches7932[]; static x64Token tokenBranches7933[]; static x64Token tokenBranches7934[]; void TokenFunc7935(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7937[]; + void TokenFunc7938(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7938[]; + static x64Token tokenBranches7939[]; static x64Token tokenBranches7940[]; void TokenFunc7941(x64Operand &operand, int tokenPos); static x64Token tokenBranches7946[]; void TokenFunc7947(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7950[]; - void TokenFunc7951(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7952[]; + void TokenFunc7953(x64Operand &operand, int tokenPos); static x64Token tokenBranches7956[]; void TokenFunc7957(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7958[]; - static x64Token tokenBranches7959[]; - static x64Token tokenBranches7960[]; - static x64Token tokenBranches7961[]; static x64Token tokenBranches7962[]; void TokenFunc7963(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7964[]; static x64Token tokenBranches7965[]; - void TokenFunc7966(x64Operand &operand, int tokenPos); static x64Token tokenBranches7966[]; static x64Token tokenBranches7967[]; static x64Token tokenBranches7968[]; void TokenFunc7969(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7971[]; + void TokenFunc7972(x64Operand &operand, int tokenPos); static x64Token tokenBranches7972[]; - void TokenFunc7973(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7973[]; + static x64Token tokenBranches7974[]; + void TokenFunc7975(x64Operand &operand, int tokenPos); static x64Token tokenBranches7978[]; void TokenFunc7979(x64Operand &operand, int tokenPos); - static x64Token tokenBranches7983[]; - void TokenFunc7984(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8023[]; - static Coding tokenCoding8024_16[]; - static Coding tokenCoding8024_17[]; - static Coding tokenCoding8024_18[]; - static Coding tokenCoding8024_19[]; - void TokenFunc8024(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8028[]; + static x64Token tokenBranches7984[]; + void TokenFunc7985(x64Operand &operand, int tokenPos); + static x64Token tokenBranches7989[]; + void TokenFunc7990(x64Operand &operand, int tokenPos); static x64Token tokenBranches8029[]; - static x64Token tokenBranches8030[]; - static x64Token tokenBranches8031[]; - static x64Token tokenBranches8032[]; - static x64Token tokenBranches8033[]; - void TokenFunc8034(x64Operand &operand, int tokenPos); + static Coding tokenCoding8030_16[]; + static Coding tokenCoding8030_17[]; + static Coding tokenCoding8030_18[]; + static Coding tokenCoding8030_19[]; + void TokenFunc8030(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8034[]; + static x64Token tokenBranches8035[]; static x64Token tokenBranches8036[]; - void TokenFunc8037(x64Operand &operand, int tokenPos); static x64Token tokenBranches8037[]; static x64Token tokenBranches8038[]; static x64Token tokenBranches8039[]; void TokenFunc8040(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8042[]; + void TokenFunc8043(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8043[]; + static x64Token tokenBranches8044[]; static x64Token tokenBranches8045[]; void TokenFunc8046(x64Operand &operand, int tokenPos); static x64Token tokenBranches8051[]; void TokenFunc8052(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8055[]; - void TokenFunc8056(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8057[]; + void TokenFunc8058(x64Operand &operand, int tokenPos); static x64Token tokenBranches8061[]; void TokenFunc8062(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8063[]; - static x64Token tokenBranches8064[]; - static x64Token tokenBranches8065[]; - static x64Token tokenBranches8066[]; static x64Token tokenBranches8067[]; void TokenFunc8068(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8069[]; static x64Token tokenBranches8070[]; - void TokenFunc8071(x64Operand &operand, int tokenPos); static x64Token tokenBranches8071[]; static x64Token tokenBranches8072[]; static x64Token tokenBranches8073[]; void TokenFunc8074(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8076[]; + void TokenFunc8077(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8077[]; + static x64Token tokenBranches8078[]; static x64Token tokenBranches8079[]; void TokenFunc8080(x64Operand &operand, int tokenPos); static x64Token tokenBranches8085[]; void TokenFunc8086(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8089[]; - void TokenFunc8090(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8091[]; + void TokenFunc8092(x64Operand &operand, int tokenPos); static x64Token tokenBranches8095[]; void TokenFunc8096(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8097[]; - static x64Token tokenBranches8098[]; - static x64Token tokenBranches8099[]; - static x64Token tokenBranches8100[]; static x64Token tokenBranches8101[]; void TokenFunc8102(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8103[]; static x64Token tokenBranches8104[]; - void TokenFunc8105(x64Operand &operand, int tokenPos); static x64Token tokenBranches8105[]; static x64Token tokenBranches8106[]; static x64Token tokenBranches8107[]; void TokenFunc8108(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8110[]; + void TokenFunc8111(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8111[]; + static x64Token tokenBranches8112[]; static x64Token tokenBranches8113[]; void TokenFunc8114(x64Operand &operand, int tokenPos); static x64Token tokenBranches8119[]; void TokenFunc8120(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8123[]; - void TokenFunc8124(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8125[]; + void TokenFunc8126(x64Operand &operand, int tokenPos); static x64Token tokenBranches8129[]; void TokenFunc8130(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8131[]; - static x64Token tokenBranches8132[]; - static x64Token tokenBranches8133[]; - static x64Token tokenBranches8134[]; static x64Token tokenBranches8135[]; void TokenFunc8136(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8137[]; static x64Token tokenBranches8138[]; - void TokenFunc8139(x64Operand &operand, int tokenPos); static x64Token tokenBranches8139[]; static x64Token tokenBranches8140[]; static x64Token tokenBranches8141[]; void TokenFunc8142(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8144[]; + void TokenFunc8145(x64Operand &operand, int tokenPos); static x64Token tokenBranches8145[]; - void TokenFunc8146(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8146[]; + static x64Token tokenBranches8147[]; + void TokenFunc8148(x64Operand &operand, int tokenPos); static x64Token tokenBranches8151[]; void TokenFunc8152(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8156[]; - void TokenFunc8157(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8158[]; - static Coding tokenCoding8159_16[]; - static Coding tokenCoding8159_17[]; - static Coding tokenCoding8159_18[]; - static Coding tokenCoding8159_19[]; - void TokenFunc8159(x64Operand &operand, int tokenPos); - static Coding tokenCoding8160_16[]; - static Coding tokenCoding8160_17[]; - static Coding tokenCoding8160_18[]; - static Coding tokenCoding8160_19[]; - void TokenFunc8160(x64Operand &operand, int tokenPos); - static Coding tokenCoding8161_16[]; - static Coding tokenCoding8161_17[]; - static Coding tokenCoding8161_18[]; - static Coding tokenCoding8161_19[]; - void TokenFunc8161(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8167[]; - static x64Token tokenBranches8168[]; - static x64Token tokenBranches8169[]; - static x64Token tokenBranches8170[]; - void TokenFunc8171(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8172[]; + static x64Token tokenBranches8157[]; + void TokenFunc8158(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8162[]; + void TokenFunc8163(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8164[]; + static Coding tokenCoding8165_16[]; + static Coding tokenCoding8165_17[]; + static Coding tokenCoding8165_18[]; + static Coding tokenCoding8165_19[]; + void TokenFunc8165(x64Operand &operand, int tokenPos); + static Coding tokenCoding8166_16[]; + static Coding tokenCoding8166_17[]; + static Coding tokenCoding8166_18[]; + static Coding tokenCoding8166_19[]; + void TokenFunc8166(x64Operand &operand, int tokenPos); + static Coding tokenCoding8167_16[]; + static Coding tokenCoding8167_17[]; + static Coding tokenCoding8167_18[]; + static Coding tokenCoding8167_19[]; + void TokenFunc8167(x64Operand &operand, int tokenPos); static x64Token tokenBranches8173[]; static x64Token tokenBranches8174[]; - void TokenFunc8175(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8175[]; static x64Token tokenBranches8176[]; - static x64Token tokenBranches8177[]; + void TokenFunc8177(x64Operand &operand, int tokenPos); static x64Token tokenBranches8178[]; - void TokenFunc8179(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8179[]; static x64Token tokenBranches8180[]; - static x64Token tokenBranches8181[]; + void TokenFunc8181(x64Operand &operand, int tokenPos); static x64Token tokenBranches8182[]; - void TokenFunc8183(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8183[]; static x64Token tokenBranches8184[]; - static x64Token tokenBranches8185[]; + void TokenFunc8185(x64Operand &operand, int tokenPos); static x64Token tokenBranches8186[]; - static Coding tokenCoding8187_16[]; - static Coding tokenCoding8187_17[]; - static Coding tokenCoding8187_18[]; - static Coding tokenCoding8187_19[]; - void TokenFunc8187(x64Operand &operand, int tokenPos); - static Coding tokenCoding8191_16[]; - static Coding tokenCoding8191_17[]; - static Coding tokenCoding8191_23[]; - static Coding tokenCoding8191_18[]; - static Coding tokenCoding8191_19[]; - void TokenFunc8191(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8187[]; + static x64Token tokenBranches8188[]; + void TokenFunc8189(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8190[]; + static x64Token tokenBranches8191[]; static x64Token tokenBranches8192[]; - static x64Token tokenBranches8193[]; - static x64Token tokenBranches8194[]; - static Coding tokenCoding8195_16[]; - static Coding tokenCoding8195_17[]; - static Coding tokenCoding8195_18[]; - static Coding tokenCoding8195_19[]; - void TokenFunc8195(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8196[]; - static x64Token tokenBranches8197[]; + static Coding tokenCoding8193_16[]; + static Coding tokenCoding8193_17[]; + static Coding tokenCoding8193_18[]; + static Coding tokenCoding8193_19[]; + void TokenFunc8193(x64Operand &operand, int tokenPos); + static Coding tokenCoding8197_16[]; + static Coding tokenCoding8197_17[]; + static Coding tokenCoding8197_23[]; + static Coding tokenCoding8197_18[]; + static Coding tokenCoding8197_19[]; + void TokenFunc8197(x64Operand &operand, int tokenPos); static x64Token tokenBranches8198[]; - static Coding tokenCoding8199_16[]; - static Coding tokenCoding8199_17[]; - static Coding tokenCoding8199_18[]; - static Coding tokenCoding8199_19[]; - void TokenFunc8199(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8199[]; static x64Token tokenBranches8200[]; - static x64Token tokenBranches8201[]; + static Coding tokenCoding8201_16[]; + static Coding tokenCoding8201_17[]; + static Coding tokenCoding8201_18[]; + static Coding tokenCoding8201_19[]; + void TokenFunc8201(x64Operand &operand, int tokenPos); static x64Token tokenBranches8202[]; - static Coding tokenCoding8203_16[]; - static Coding tokenCoding8203_17[]; - static Coding tokenCoding8203_18[]; - static Coding tokenCoding8203_19[]; - void TokenFunc8203(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8203[]; static x64Token tokenBranches8204[]; - static x64Token tokenBranches8205[]; - static Coding tokenCoding8206_16[]; - static Coding tokenCoding8206_17[]; - static Coding tokenCoding8206_18[]; - static Coding tokenCoding8206_19[]; - void TokenFunc8206(x64Operand &operand, int tokenPos); + static Coding tokenCoding8205_16[]; + static Coding tokenCoding8205_17[]; + static Coding tokenCoding8205_18[]; + static Coding tokenCoding8205_19[]; + void TokenFunc8205(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8206[]; static x64Token tokenBranches8207[]; static x64Token tokenBranches8208[]; static Coding tokenCoding8209_16[]; static Coding tokenCoding8209_17[]; - static Coding tokenCoding8209_23[]; static Coding tokenCoding8209_18[]; static Coding tokenCoding8209_19[]; void TokenFunc8209(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8210[]; + static x64Token tokenBranches8211[]; static Coding tokenCoding8212_16[]; static Coding tokenCoding8212_17[]; - static Coding tokenCoding8212_23[]; static Coding tokenCoding8212_18[]; static Coding tokenCoding8212_19[]; void TokenFunc8212(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8213[]; + static x64Token tokenBranches8214[]; static Coding tokenCoding8215_16[]; static Coding tokenCoding8215_17[]; static Coding tokenCoding8215_23[]; static Coding tokenCoding8215_18[]; static Coding tokenCoding8215_19[]; void TokenFunc8215(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8216[]; - static x64Token tokenBranches8217[]; static Coding tokenCoding8218_16[]; static Coding tokenCoding8218_17[]; + static Coding tokenCoding8218_23[]; static Coding tokenCoding8218_18[]; static Coding tokenCoding8218_19[]; void TokenFunc8218(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8219[]; - static x64Token tokenBranches8220[]; static Coding tokenCoding8221_16[]; static Coding tokenCoding8221_17[]; + static Coding tokenCoding8221_23[]; static Coding tokenCoding8221_18[]; static Coding tokenCoding8221_19[]; void TokenFunc8221(x64Operand &operand, int tokenPos); @@ -5497,178 +5497,184 @@ class x64Parser : public InstructionParser static Coding tokenCoding8224_18[]; static Coding tokenCoding8224_19[]; void TokenFunc8224(x64Operand &operand, int tokenPos); - void TokenFunc8225(x64Operand &operand, int tokenPos); static x64Token tokenBranches8225[]; static x64Token tokenBranches8226[]; - static x64Token tokenBranches8227[]; - static Coding tokenCoding8228_16[]; - static Coding tokenCoding8228_17[]; - static Coding tokenCoding8228_18[]; - static Coding tokenCoding8228_19[]; - void TokenFunc8228(x64Operand &operand, int tokenPos); - void TokenFunc8229(x64Operand &operand, int tokenPos); + static Coding tokenCoding8227_16[]; + static Coding tokenCoding8227_17[]; + static Coding tokenCoding8227_18[]; + static Coding tokenCoding8227_19[]; + void TokenFunc8227(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8228[]; static x64Token tokenBranches8229[]; - static x64Token tokenBranches8230[]; + static Coding tokenCoding8230_16[]; + static Coding tokenCoding8230_17[]; + static Coding tokenCoding8230_18[]; + static Coding tokenCoding8230_19[]; + void TokenFunc8230(x64Operand &operand, int tokenPos); + void TokenFunc8231(x64Operand &operand, int tokenPos); static x64Token tokenBranches8231[]; - static Coding tokenCoding8232_16[]; - static Coding tokenCoding8232_17[]; - static Coding tokenCoding8232_23[]; - static Coding tokenCoding8232_18[]; - static Coding tokenCoding8232_19[]; - void TokenFunc8232(x64Operand &operand, int tokenPos); - void TokenFunc8233(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8232[]; static x64Token tokenBranches8233[]; - static x64Token tokenBranches8234[]; + static Coding tokenCoding8234_16[]; + static Coding tokenCoding8234_17[]; + static Coding tokenCoding8234_18[]; + static Coding tokenCoding8234_19[]; + void TokenFunc8234(x64Operand &operand, int tokenPos); + void TokenFunc8235(x64Operand &operand, int tokenPos); static x64Token tokenBranches8235[]; - static Coding tokenCoding8236_16[]; - static Coding tokenCoding8236_17[]; - static Coding tokenCoding8236_18[]; - static Coding tokenCoding8236_19[]; - void TokenFunc8236(x64Operand &operand, int tokenPos); - void TokenFunc8237(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8236[]; static x64Token tokenBranches8237[]; - static x64Token tokenBranches8238[]; + static Coding tokenCoding8238_16[]; + static Coding tokenCoding8238_17[]; + static Coding tokenCoding8238_23[]; + static Coding tokenCoding8238_18[]; + static Coding tokenCoding8238_19[]; + void TokenFunc8238(x64Operand &operand, int tokenPos); + void TokenFunc8239(x64Operand &operand, int tokenPos); static x64Token tokenBranches8239[]; - static Coding tokenCoding8240_16[]; - static Coding tokenCoding8240_17[]; - static Coding tokenCoding8240_18[]; - static Coding tokenCoding8240_19[]; - void TokenFunc8240(x64Operand &operand, int tokenPos); - void TokenFunc8241(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8240[]; static x64Token tokenBranches8241[]; - static x64Token tokenBranches8242[]; + static Coding tokenCoding8242_16[]; + static Coding tokenCoding8242_17[]; + static Coding tokenCoding8242_18[]; + static Coding tokenCoding8242_19[]; + void TokenFunc8242(x64Operand &operand, int tokenPos); + void TokenFunc8243(x64Operand &operand, int tokenPos); static x64Token tokenBranches8243[]; - static Coding tokenCoding8244_16[]; - static Coding tokenCoding8244_17[]; - static Coding tokenCoding8244_18[]; - static Coding tokenCoding8244_19[]; - void TokenFunc8244(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8244[]; + static x64Token tokenBranches8245[]; + static Coding tokenCoding8246_16[]; + static Coding tokenCoding8246_17[]; + static Coding tokenCoding8246_18[]; + static Coding tokenCoding8246_19[]; + void TokenFunc8246(x64Operand &operand, int tokenPos); + void TokenFunc8247(x64Operand &operand, int tokenPos); static x64Token tokenBranches8247[]; - static Coding tokenCoding8248_16[]; - static Coding tokenCoding8248_17[]; - static Coding tokenCoding8248_18[]; - static Coding tokenCoding8248_19[]; - void TokenFunc8248(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8251[]; - static Coding tokenCoding8252_16[]; - static Coding tokenCoding8252_17[]; - static Coding tokenCoding8252_18[]; - static Coding tokenCoding8252_19[]; - void TokenFunc8252(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8255[]; - static Coding tokenCoding8256_16[]; - static Coding tokenCoding8256_17[]; - static Coding tokenCoding8256_18[]; - static Coding tokenCoding8256_19[]; - void TokenFunc8256(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8259[]; - static Coding tokenCoding8260_16[]; - static Coding tokenCoding8260_17[]; - static Coding tokenCoding8260_18[]; - static Coding tokenCoding8260_19[]; - void TokenFunc8260(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8248[]; + static x64Token tokenBranches8249[]; + static Coding tokenCoding8250_16[]; + static Coding tokenCoding8250_17[]; + static Coding tokenCoding8250_18[]; + static Coding tokenCoding8250_19[]; + void TokenFunc8250(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8253[]; + static Coding tokenCoding8254_16[]; + static Coding tokenCoding8254_17[]; + static Coding tokenCoding8254_18[]; + static Coding tokenCoding8254_19[]; + void TokenFunc8254(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8257[]; + static Coding tokenCoding8258_16[]; + static Coding tokenCoding8258_17[]; + static Coding tokenCoding8258_18[]; + static Coding tokenCoding8258_19[]; + void TokenFunc8258(x64Operand &operand, int tokenPos); static x64Token tokenBranches8261[]; - static x64Token tokenBranches8262[]; - static x64Token tokenBranches8263[]; - static x64Token tokenBranches8264[]; - static Coding tokenCoding8265_16[]; - static Coding tokenCoding8265_17[]; - static Coding tokenCoding8265_18[]; - static Coding tokenCoding8265_19[]; - void TokenFunc8265(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8266[]; + static Coding tokenCoding8262_16[]; + static Coding tokenCoding8262_17[]; + static Coding tokenCoding8262_18[]; + static Coding tokenCoding8262_19[]; + void TokenFunc8262(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8265[]; + static Coding tokenCoding8266_16[]; + static Coding tokenCoding8266_17[]; + static Coding tokenCoding8266_18[]; + static Coding tokenCoding8266_19[]; + void TokenFunc8266(x64Operand &operand, int tokenPos); static x64Token tokenBranches8267[]; static x64Token tokenBranches8268[]; static x64Token tokenBranches8269[]; - static Coding tokenCoding8270_16[]; - static Coding tokenCoding8270_17[]; - static Coding tokenCoding8270_18[]; - static Coding tokenCoding8270_19[]; - void TokenFunc8270(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8271[]; + static x64Token tokenBranches8270[]; + static Coding tokenCoding8271_16[]; + static Coding tokenCoding8271_17[]; + static Coding tokenCoding8271_18[]; + static Coding tokenCoding8271_19[]; + void TokenFunc8271(x64Operand &operand, int tokenPos); static x64Token tokenBranches8272[]; static x64Token tokenBranches8273[]; static x64Token tokenBranches8274[]; - static Coding tokenCoding8275_16[]; - static Coding tokenCoding8275_17[]; - static Coding tokenCoding8275_18[]; - static Coding tokenCoding8275_19[]; - void TokenFunc8275(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8276[]; + static x64Token tokenBranches8275[]; + static Coding tokenCoding8276_16[]; + static Coding tokenCoding8276_17[]; + static Coding tokenCoding8276_18[]; + static Coding tokenCoding8276_19[]; + void TokenFunc8276(x64Operand &operand, int tokenPos); static x64Token tokenBranches8277[]; static x64Token tokenBranches8278[]; static x64Token tokenBranches8279[]; - static Coding tokenCoding8280_16[]; - static Coding tokenCoding8280_17[]; - static Coding tokenCoding8280_18[]; - static Coding tokenCoding8280_19[]; - void TokenFunc8280(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8280[]; + static Coding tokenCoding8281_16[]; + static Coding tokenCoding8281_17[]; + static Coding tokenCoding8281_18[]; + static Coding tokenCoding8281_19[]; + void TokenFunc8281(x64Operand &operand, int tokenPos); static x64Token tokenBranches8282[]; - static Coding tokenCoding8283_16[]; - static Coding tokenCoding8283_17[]; - static Coding tokenCoding8283_18[]; - static Coding tokenCoding8283_19[]; - void TokenFunc8283(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8283[]; static x64Token tokenBranches8284[]; - static Coding tokenCoding8285_16[]; - static Coding tokenCoding8285_17[]; - static Coding tokenCoding8285_18[]; - static Coding tokenCoding8285_19[]; - void TokenFunc8285(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8289[]; + static x64Token tokenBranches8285[]; + static Coding tokenCoding8286_16[]; + static Coding tokenCoding8286_17[]; + static Coding tokenCoding8286_18[]; + static Coding tokenCoding8286_19[]; + void TokenFunc8286(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8288[]; + static Coding tokenCoding8289_16[]; + static Coding tokenCoding8289_17[]; + static Coding tokenCoding8289_18[]; + static Coding tokenCoding8289_19[]; + void TokenFunc8289(x64Operand &operand, int tokenPos); static x64Token tokenBranches8290[]; - static x64Token tokenBranches8291[]; - static x64Token tokenBranches8292[]; - static Coding tokenCoding8293_16[]; - static Coding tokenCoding8293_17[]; - static Coding tokenCoding8293_18[]; - static Coding tokenCoding8293_19[]; - void TokenFunc8293(x64Operand &operand, int tokenPos); - static Coding tokenCoding8297_16[]; - static Coding tokenCoding8297_17[]; - static Coding tokenCoding8297_23[]; - static Coding tokenCoding8297_18[]; - static Coding tokenCoding8297_19[]; - void TokenFunc8297(x64Operand &operand, int tokenPos); + static Coding tokenCoding8291_16[]; + static Coding tokenCoding8291_17[]; + static Coding tokenCoding8291_18[]; + static Coding tokenCoding8291_19[]; + void TokenFunc8291(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8295[]; + static x64Token tokenBranches8296[]; + static x64Token tokenBranches8297[]; static x64Token tokenBranches8298[]; - static x64Token tokenBranches8299[]; - static x64Token tokenBranches8300[]; - static Coding tokenCoding8301_16[]; - static Coding tokenCoding8301_17[]; - static Coding tokenCoding8301_18[]; - static Coding tokenCoding8301_19[]; - void TokenFunc8301(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8302[]; - static x64Token tokenBranches8303[]; + static Coding tokenCoding8299_16[]; + static Coding tokenCoding8299_17[]; + static Coding tokenCoding8299_18[]; + static Coding tokenCoding8299_19[]; + void TokenFunc8299(x64Operand &operand, int tokenPos); + static Coding tokenCoding8303_16[]; + static Coding tokenCoding8303_17[]; + static Coding tokenCoding8303_23[]; + static Coding tokenCoding8303_18[]; + static Coding tokenCoding8303_19[]; + void TokenFunc8303(x64Operand &operand, int tokenPos); static x64Token tokenBranches8304[]; - static Coding tokenCoding8305_16[]; - static Coding tokenCoding8305_17[]; - static Coding tokenCoding8305_18[]; - static Coding tokenCoding8305_19[]; - void TokenFunc8305(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8305[]; static x64Token tokenBranches8306[]; - static x64Token tokenBranches8307[]; + static Coding tokenCoding8307_16[]; + static Coding tokenCoding8307_17[]; + static Coding tokenCoding8307_18[]; + static Coding tokenCoding8307_19[]; + void TokenFunc8307(x64Operand &operand, int tokenPos); static x64Token tokenBranches8308[]; - static Coding tokenCoding8309_16[]; - static Coding tokenCoding8309_17[]; - static Coding tokenCoding8309_18[]; - static Coding tokenCoding8309_19[]; - void TokenFunc8309(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8309[]; static x64Token tokenBranches8310[]; - static x64Token tokenBranches8311[]; + static Coding tokenCoding8311_16[]; + static Coding tokenCoding8311_17[]; + static Coding tokenCoding8311_18[]; + static Coding tokenCoding8311_19[]; + void TokenFunc8311(x64Operand &operand, int tokenPos); static x64Token tokenBranches8312[]; - void TokenFunc8313(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8313[]; static x64Token tokenBranches8314[]; - static x64Token tokenBranches8315[]; - void TokenFunc8316(x64Operand &operand, int tokenPos); + static Coding tokenCoding8315_16[]; + static Coding tokenCoding8315_17[]; + static Coding tokenCoding8315_18[]; + static Coding tokenCoding8315_19[]; + void TokenFunc8315(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8316[]; static x64Token tokenBranches8317[]; static x64Token tokenBranches8318[]; void TokenFunc8319(x64Operand &operand, int tokenPos); - void TokenFunc8320(x64Operand &operand, int tokenPos); static x64Token tokenBranches8320[]; static x64Token tokenBranches8321[]; void TokenFunc8322(x64Operand &operand, int tokenPos); - void TokenFunc8323(x64Operand &operand, int tokenPos); static x64Token tokenBranches8323[]; static x64Token tokenBranches8324[]; void TokenFunc8325(x64Operand &operand, int tokenPos); @@ -5679,90 +5685,96 @@ class x64Parser : public InstructionParser void TokenFunc8329(x64Operand &operand, int tokenPos); static x64Token tokenBranches8329[]; static x64Token tokenBranches8330[]; - static x64Token tokenBranches8331[]; - static Coding tokenCoding8332_16[]; - static Coding tokenCoding8332_17[]; - static Coding tokenCoding8332_18[]; - static Coding tokenCoding8332_19[]; + void TokenFunc8331(x64Operand &operand, int tokenPos); void TokenFunc8332(x64Operand &operand, int tokenPos); - void TokenFunc8333(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8332[]; static x64Token tokenBranches8333[]; - static x64Token tokenBranches8334[]; + void TokenFunc8334(x64Operand &operand, int tokenPos); + void TokenFunc8335(x64Operand &operand, int tokenPos); static x64Token tokenBranches8335[]; - static Coding tokenCoding8336_16[]; - static Coding tokenCoding8336_17[]; - static Coding tokenCoding8336_23[]; - static Coding tokenCoding8336_18[]; - static Coding tokenCoding8336_19[]; - void TokenFunc8336(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8336[]; + static x64Token tokenBranches8337[]; + static Coding tokenCoding8338_16[]; + static Coding tokenCoding8338_17[]; + static Coding tokenCoding8338_18[]; + static Coding tokenCoding8338_19[]; + void TokenFunc8338(x64Operand &operand, int tokenPos); + void TokenFunc8339(x64Operand &operand, int tokenPos); static x64Token tokenBranches8339[]; - static Coding tokenCoding8340_16[]; - static Coding tokenCoding8340_17[]; - static Coding tokenCoding8340_18[]; - static Coding tokenCoding8340_19[]; - void TokenFunc8340(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8343[]; - static Coding tokenCoding8344_16[]; - static Coding tokenCoding8344_17[]; - static Coding tokenCoding8344_18[]; - static Coding tokenCoding8344_19[]; - void TokenFunc8344(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8347[]; - static Coding tokenCoding8348_16[]; - static Coding tokenCoding8348_17[]; - static Coding tokenCoding8348_18[]; - static Coding tokenCoding8348_19[]; - void TokenFunc8348(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8340[]; + static x64Token tokenBranches8341[]; + static Coding tokenCoding8342_16[]; + static Coding tokenCoding8342_17[]; + static Coding tokenCoding8342_23[]; + static Coding tokenCoding8342_18[]; + static Coding tokenCoding8342_19[]; + void TokenFunc8342(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8345[]; + static Coding tokenCoding8346_16[]; + static Coding tokenCoding8346_17[]; + static Coding tokenCoding8346_18[]; + static Coding tokenCoding8346_19[]; + void TokenFunc8346(x64Operand &operand, int tokenPos); static x64Token tokenBranches8349[]; - static x64Token tokenBranches8350[]; - static x64Token tokenBranches8351[]; - static Coding tokenCoding8352_16[]; - static Coding tokenCoding8352_17[]; - static Coding tokenCoding8352_18[]; - static Coding tokenCoding8352_19[]; - void TokenFunc8352(x64Operand &operand, int tokenPos); - static Coding tokenCoding8356_16[]; - static Coding tokenCoding8356_17[]; - static Coding tokenCoding8356_23[]; - static Coding tokenCoding8356_18[]; - static Coding tokenCoding8356_19[]; - void TokenFunc8356(x64Operand &operand, int tokenPos); + static Coding tokenCoding8350_16[]; + static Coding tokenCoding8350_17[]; + static Coding tokenCoding8350_18[]; + static Coding tokenCoding8350_19[]; + void TokenFunc8350(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8353[]; + static Coding tokenCoding8354_16[]; + static Coding tokenCoding8354_17[]; + static Coding tokenCoding8354_18[]; + static Coding tokenCoding8354_19[]; + void TokenFunc8354(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8355[]; + static x64Token tokenBranches8356[]; static x64Token tokenBranches8357[]; - static x64Token tokenBranches8358[]; - static x64Token tokenBranches8359[]; - static Coding tokenCoding8360_16[]; - static Coding tokenCoding8360_17[]; - static Coding tokenCoding8360_18[]; - static Coding tokenCoding8360_19[]; - void TokenFunc8360(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8361[]; - static x64Token tokenBranches8362[]; + static Coding tokenCoding8358_16[]; + static Coding tokenCoding8358_17[]; + static Coding tokenCoding8358_18[]; + static Coding tokenCoding8358_19[]; + void TokenFunc8358(x64Operand &operand, int tokenPos); + static Coding tokenCoding8362_16[]; + static Coding tokenCoding8362_17[]; + static Coding tokenCoding8362_23[]; + static Coding tokenCoding8362_18[]; + static Coding tokenCoding8362_19[]; + void TokenFunc8362(x64Operand &operand, int tokenPos); static x64Token tokenBranches8363[]; - static Coding tokenCoding8364_16[]; - static Coding tokenCoding8364_17[]; - static Coding tokenCoding8364_18[]; - static Coding tokenCoding8364_19[]; - void TokenFunc8364(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8364[]; static x64Token tokenBranches8365[]; - static x64Token tokenBranches8366[]; + static Coding tokenCoding8366_16[]; + static Coding tokenCoding8366_17[]; + static Coding tokenCoding8366_18[]; + static Coding tokenCoding8366_19[]; + void TokenFunc8366(x64Operand &operand, int tokenPos); static x64Token tokenBranches8367[]; - static Coding tokenCoding8368_16[]; - static Coding tokenCoding8368_17[]; - static Coding tokenCoding8368_18[]; - static Coding tokenCoding8368_19[]; - void TokenFunc8368(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8368[]; static x64Token tokenBranches8369[]; - static x64Token tokenBranches8370[]; + static Coding tokenCoding8370_16[]; + static Coding tokenCoding8370_17[]; + static Coding tokenCoding8370_18[]; + static Coding tokenCoding8370_19[]; + void TokenFunc8370(x64Operand &operand, int tokenPos); static x64Token tokenBranches8371[]; static x64Token tokenBranches8372[]; static x64Token tokenBranches8373[]; - static x64Token tokenBranches8374[]; - void TokenFunc8375(x64Operand &operand, int tokenPos); - void TokenFunc8378(x64Operand &operand, int tokenPos); + static Coding tokenCoding8374_16[]; + static Coding tokenCoding8374_17[]; + static Coding tokenCoding8374_18[]; + static Coding tokenCoding8374_19[]; + void TokenFunc8374(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8375[]; + static x64Token tokenBranches8376[]; + static x64Token tokenBranches8377[]; static x64Token tokenBranches8378[]; static x64Token tokenBranches8379[]; static x64Token tokenBranches8380[]; void TokenFunc8381(x64Operand &operand, int tokenPos); + void TokenFunc8384(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8384[]; + static x64Token tokenBranches8385[]; static x64Token tokenBranches8386[]; void TokenFunc8387(x64Operand &operand, int tokenPos); static x64Token tokenBranches8392[]; @@ -5771,70 +5783,55 @@ class x64Parser : public InstructionParser void TokenFunc8399(x64Operand &operand, int tokenPos); static x64Token tokenBranches8404[]; void TokenFunc8405(x64Operand &operand, int tokenPos); - void TokenFunc8406(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8409[]; - static Coding tokenCoding8410_16[]; - static Coding tokenCoding8410_17[]; - static Coding tokenCoding8410_18[]; - static Coding tokenCoding8410_19[]; - void TokenFunc8410(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8411[]; - static Coding tokenCoding8412_16[]; - static Coding tokenCoding8412_17[]; - static Coding tokenCoding8412_18[]; - static Coding tokenCoding8412_19[]; + static x64Token tokenBranches8410[]; + void TokenFunc8411(x64Operand &operand, int tokenPos); void TokenFunc8412(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8413[]; - static Coding tokenCoding8414_16[]; - static Coding tokenCoding8414_17[]; - static Coding tokenCoding8414_18[]; - static Coding tokenCoding8414_19[]; - void TokenFunc8414(x64Operand &operand, int tokenPos); static x64Token tokenBranches8415[]; static Coding tokenCoding8416_16[]; static Coding tokenCoding8416_17[]; static Coding tokenCoding8416_18[]; static Coding tokenCoding8416_19[]; void TokenFunc8416(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8466[]; - void TokenFunc8467(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8467[]; - static x64Token tokenBranches8468[]; - static Coding tokenCoding8469_16[]; - static Coding tokenCoding8469_17[]; - static Coding tokenCoding8469_23[]; - static Coding tokenCoding8469_18[]; - static Coding tokenCoding8469_19[]; - void TokenFunc8469(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8470[]; - void TokenFunc8471(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8471[]; + static x64Token tokenBranches8417[]; + static Coding tokenCoding8418_16[]; + static Coding tokenCoding8418_17[]; + static Coding tokenCoding8418_18[]; + static Coding tokenCoding8418_19[]; + void TokenFunc8418(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8419[]; + static Coding tokenCoding8420_16[]; + static Coding tokenCoding8420_17[]; + static Coding tokenCoding8420_18[]; + static Coding tokenCoding8420_19[]; + void TokenFunc8420(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8421[]; + static Coding tokenCoding8422_16[]; + static Coding tokenCoding8422_17[]; + static Coding tokenCoding8422_18[]; + static Coding tokenCoding8422_19[]; + void TokenFunc8422(x64Operand &operand, int tokenPos); static x64Token tokenBranches8472[]; - static Coding tokenCoding8473_16[]; - static Coding tokenCoding8473_17[]; - static Coding tokenCoding8473_23[]; - static Coding tokenCoding8473_18[]; - static Coding tokenCoding8473_19[]; void TokenFunc8473(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8487[]; - void TokenFunc8488(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8488[]; - static x64Token tokenBranches8489[]; - static Coding tokenCoding8490_16[]; - static Coding tokenCoding8490_17[]; - static Coding tokenCoding8490_23[]; - static Coding tokenCoding8490_18[]; - static Coding tokenCoding8490_19[]; - void TokenFunc8490(x64Operand &operand, int tokenPos); - void TokenFunc8491(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8491[]; - static x64Token tokenBranches8492[]; - static Coding tokenCoding8493_16[]; - static Coding tokenCoding8493_17[]; - static Coding tokenCoding8493_23[]; - static Coding tokenCoding8493_18[]; - static Coding tokenCoding8493_19[]; - void TokenFunc8493(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8473[]; + static x64Token tokenBranches8474[]; + static Coding tokenCoding8475_16[]; + static Coding tokenCoding8475_17[]; + static Coding tokenCoding8475_23[]; + static Coding tokenCoding8475_18[]; + static Coding tokenCoding8475_19[]; + void TokenFunc8475(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8476[]; + void TokenFunc8477(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8477[]; + static x64Token tokenBranches8478[]; + static Coding tokenCoding8479_16[]; + static Coding tokenCoding8479_17[]; + static Coding tokenCoding8479_23[]; + static Coding tokenCoding8479_18[]; + static Coding tokenCoding8479_19[]; + void TokenFunc8479(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8493[]; + void TokenFunc8494(x64Operand &operand, int tokenPos); static x64Token tokenBranches8494[]; static x64Token tokenBranches8495[]; static Coding tokenCoding8496_16[]; @@ -5843,6 +5840,9 @@ class x64Parser : public InstructionParser static Coding tokenCoding8496_18[]; static Coding tokenCoding8496_19[]; void TokenFunc8496(x64Operand &operand, int tokenPos); + void TokenFunc8497(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8497[]; + static x64Token tokenBranches8498[]; static Coding tokenCoding8499_16[]; static Coding tokenCoding8499_17[]; static Coding tokenCoding8499_23[]; @@ -5851,23 +5851,19 @@ class x64Parser : public InstructionParser void TokenFunc8499(x64Operand &operand, int tokenPos); static x64Token tokenBranches8500[]; static x64Token tokenBranches8501[]; - static x64Token tokenBranches8502[]; - static Coding tokenCoding8503_16[]; - static Coding tokenCoding8503_17[]; - static Coding tokenCoding8503_23[]; - static Coding tokenCoding8503_18[]; - static Coding tokenCoding8503_19[]; - void TokenFunc8503(x64Operand &operand, int tokenPos); - void TokenFunc8504(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8504[]; - static x64Token tokenBranches8505[]; - static Coding tokenCoding8506_16[]; - static Coding tokenCoding8506_17[]; - static Coding tokenCoding8506_23[]; - static Coding tokenCoding8506_18[]; - static Coding tokenCoding8506_19[]; - void TokenFunc8506(x64Operand &operand, int tokenPos); - void TokenFunc8507(x64Operand &operand, int tokenPos); + static Coding tokenCoding8502_16[]; + static Coding tokenCoding8502_17[]; + static Coding tokenCoding8502_23[]; + static Coding tokenCoding8502_18[]; + static Coding tokenCoding8502_19[]; + void TokenFunc8502(x64Operand &operand, int tokenPos); + static Coding tokenCoding8505_16[]; + static Coding tokenCoding8505_17[]; + static Coding tokenCoding8505_23[]; + static Coding tokenCoding8505_18[]; + static Coding tokenCoding8505_19[]; + void TokenFunc8505(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8506[]; static x64Token tokenBranches8507[]; static x64Token tokenBranches8508[]; static Coding tokenCoding8509_16[]; @@ -5876,12 +5872,16 @@ class x64Parser : public InstructionParser static Coding tokenCoding8509_18[]; static Coding tokenCoding8509_19[]; void TokenFunc8509(x64Operand &operand, int tokenPos); + void TokenFunc8510(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8510[]; + static x64Token tokenBranches8511[]; static Coding tokenCoding8512_16[]; static Coding tokenCoding8512_17[]; static Coding tokenCoding8512_23[]; static Coding tokenCoding8512_18[]; static Coding tokenCoding8512_19[]; void TokenFunc8512(x64Operand &operand, int tokenPos); + void TokenFunc8513(x64Operand &operand, int tokenPos); static x64Token tokenBranches8513[]; static x64Token tokenBranches8514[]; static Coding tokenCoding8515_16[]; @@ -5890,36 +5890,40 @@ class x64Parser : public InstructionParser static Coding tokenCoding8515_18[]; static Coding tokenCoding8515_19[]; void TokenFunc8515(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8516[]; - static x64Token tokenBranches8517[]; static Coding tokenCoding8518_16[]; static Coding tokenCoding8518_17[]; static Coding tokenCoding8518_23[]; static Coding tokenCoding8518_18[]; static Coding tokenCoding8518_19[]; void TokenFunc8518(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8519[]; + static x64Token tokenBranches8520[]; static Coding tokenCoding8521_16[]; static Coding tokenCoding8521_17[]; static Coding tokenCoding8521_23[]; static Coding tokenCoding8521_18[]; static Coding tokenCoding8521_19[]; void TokenFunc8521(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8522[]; + static x64Token tokenBranches8523[]; static Coding tokenCoding8524_16[]; static Coding tokenCoding8524_17[]; static Coding tokenCoding8524_23[]; static Coding tokenCoding8524_18[]; static Coding tokenCoding8524_19[]; void TokenFunc8524(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8529[]; + static Coding tokenCoding8527_16[]; + static Coding tokenCoding8527_17[]; + static Coding tokenCoding8527_23[]; + static Coding tokenCoding8527_18[]; + static Coding tokenCoding8527_19[]; + void TokenFunc8527(x64Operand &operand, int tokenPos); + static Coding tokenCoding8530_16[]; + static Coding tokenCoding8530_17[]; + static Coding tokenCoding8530_23[]; + static Coding tokenCoding8530_18[]; + static Coding tokenCoding8530_19[]; void TokenFunc8530(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8530[]; - static x64Token tokenBranches8531[]; - static Coding tokenCoding8532_16[]; - static Coding tokenCoding8532_17[]; - static Coding tokenCoding8532_23[]; - static Coding tokenCoding8532_18[]; - static Coding tokenCoding8532_19[]; - void TokenFunc8532(x64Operand &operand, int tokenPos); static x64Token tokenBranches8535[]; void TokenFunc8536(x64Operand &operand, int tokenPos); static x64Token tokenBranches8536[]; @@ -5930,95 +5934,94 @@ class x64Parser : public InstructionParser static Coding tokenCoding8538_18[]; static Coding tokenCoding8538_19[]; void TokenFunc8538(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8541[]; + void TokenFunc8542(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8542[]; static x64Token tokenBranches8543[]; - static x64Token tokenBranches8544[]; - static x64Token tokenBranches8545[]; - static Coding tokenCoding8546_16[]; - static Coding tokenCoding8546_17[]; - static Coding tokenCoding8546_23[]; - static Coding tokenCoding8546_18[]; - static Coding tokenCoding8546_19[]; - void TokenFunc8546(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8547[]; - static x64Token tokenBranches8548[]; + static Coding tokenCoding8544_16[]; + static Coding tokenCoding8544_17[]; + static Coding tokenCoding8544_23[]; + static Coding tokenCoding8544_18[]; + static Coding tokenCoding8544_19[]; + void TokenFunc8544(x64Operand &operand, int tokenPos); static x64Token tokenBranches8549[]; - static Coding tokenCoding8550_16[]; - static Coding tokenCoding8550_17[]; - static Coding tokenCoding8550_18[]; - void TokenFunc8550(x64Operand &operand, int tokenPos); - static Coding tokenCoding8553_16[]; - static Coding tokenCoding8553_17[]; - static Coding tokenCoding8553_18[]; - void TokenFunc8553(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8550[]; + static x64Token tokenBranches8551[]; + static Coding tokenCoding8552_16[]; + static Coding tokenCoding8552_17[]; + static Coding tokenCoding8552_23[]; + static Coding tokenCoding8552_18[]; + static Coding tokenCoding8552_19[]; + void TokenFunc8552(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8553[]; static x64Token tokenBranches8554[]; static x64Token tokenBranches8555[]; - static x64Token tokenBranches8556[]; - static Coding tokenCoding8557_16[]; - static Coding tokenCoding8557_17[]; - static Coding tokenCoding8557_23[]; - static Coding tokenCoding8557_18[]; - static Coding tokenCoding8557_19[]; - void TokenFunc8557(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8558[]; - static x64Token tokenBranches8559[]; + static Coding tokenCoding8556_16[]; + static Coding tokenCoding8556_17[]; + static Coding tokenCoding8556_18[]; + void TokenFunc8556(x64Operand &operand, int tokenPos); + static Coding tokenCoding8559_16[]; + static Coding tokenCoding8559_17[]; + static Coding tokenCoding8559_18[]; + void TokenFunc8559(x64Operand &operand, int tokenPos); static x64Token tokenBranches8560[]; - static Coding tokenCoding8561_16[]; - static Coding tokenCoding8561_17[]; - static Coding tokenCoding8561_23[]; - static Coding tokenCoding8561_18[]; - static Coding tokenCoding8561_19[]; - void TokenFunc8561(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8561[]; static x64Token tokenBranches8562[]; - static x64Token tokenBranches8563[]; + static Coding tokenCoding8563_16[]; + static Coding tokenCoding8563_17[]; + static Coding tokenCoding8563_23[]; + static Coding tokenCoding8563_18[]; + static Coding tokenCoding8563_19[]; + void TokenFunc8563(x64Operand &operand, int tokenPos); static x64Token tokenBranches8564[]; - static Coding tokenCoding8565_16[]; - static Coding tokenCoding8565_17[]; - static Coding tokenCoding8565_23[]; - static Coding tokenCoding8565_18[]; - static Coding tokenCoding8565_19[]; - void TokenFunc8565(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8565[]; static x64Token tokenBranches8566[]; + static Coding tokenCoding8567_16[]; + static Coding tokenCoding8567_17[]; + static Coding tokenCoding8567_23[]; + static Coding tokenCoding8567_18[]; + static Coding tokenCoding8567_19[]; void TokenFunc8567(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8567[]; static x64Token tokenBranches8568[]; - static Coding tokenCoding8569_16[]; - static Coding tokenCoding8569_17[]; - static Coding tokenCoding8569_23[]; - static Coding tokenCoding8569_18[]; - static Coding tokenCoding8569_19[]; - void TokenFunc8569(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8592[]; - void TokenFunc8593(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8593[]; - static x64Token tokenBranches8594[]; - static x64Token tokenBranches8595[]; - static x64Token tokenBranches8596[]; - static Coding tokenCoding8597_16[]; - static Coding tokenCoding8597_17[]; - static Coding tokenCoding8597_23[]; - static Coding tokenCoding8597_18[]; - void TokenFunc8597(x64Operand &operand, int tokenPos); - void TokenFunc8598(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8569[]; + static x64Token tokenBranches8570[]; + static Coding tokenCoding8571_16[]; + static Coding tokenCoding8571_17[]; + static Coding tokenCoding8571_23[]; + static Coding tokenCoding8571_18[]; + static Coding tokenCoding8571_19[]; + void TokenFunc8571(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8572[]; + void TokenFunc8573(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8573[]; + static x64Token tokenBranches8574[]; + static Coding tokenCoding8575_16[]; + static Coding tokenCoding8575_17[]; + static Coding tokenCoding8575_23[]; + static Coding tokenCoding8575_18[]; + static Coding tokenCoding8575_19[]; + void TokenFunc8575(x64Operand &operand, int tokenPos); static x64Token tokenBranches8598[]; + void TokenFunc8599(x64Operand &operand, int tokenPos); static x64Token tokenBranches8599[]; static x64Token tokenBranches8600[]; static x64Token tokenBranches8601[]; - static Coding tokenCoding8602_16[]; - static Coding tokenCoding8602_17[]; - static Coding tokenCoding8602_23[]; - static Coding tokenCoding8602_18[]; - void TokenFunc8602(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8616[]; - static x64Token tokenBranches8617[]; - static x64Token tokenBranches8618[]; - void TokenFunc8619(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8619[]; - static x64Token tokenBranches8620[]; - static Coding tokenCoding8621_16[]; - static Coding tokenCoding8621_17[]; - static Coding tokenCoding8621_23[]; - static Coding tokenCoding8621_18[]; - void TokenFunc8621(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8602[]; + static Coding tokenCoding8603_16[]; + static Coding tokenCoding8603_17[]; + static Coding tokenCoding8603_23[]; + static Coding tokenCoding8603_18[]; + void TokenFunc8603(x64Operand &operand, int tokenPos); + void TokenFunc8604(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8604[]; + static x64Token tokenBranches8605[]; + static x64Token tokenBranches8606[]; + static x64Token tokenBranches8607[]; + static Coding tokenCoding8608_16[]; + static Coding tokenCoding8608_17[]; + static Coding tokenCoding8608_23[]; + static Coding tokenCoding8608_18[]; + void TokenFunc8608(x64Operand &operand, int tokenPos); static x64Token tokenBranches8622[]; static x64Token tokenBranches8623[]; static x64Token tokenBranches8624[]; @@ -6051,51 +6054,51 @@ class x64Parser : public InstructionParser static Coding tokenCoding8639_17[]; static Coding tokenCoding8639_23[]; static Coding tokenCoding8639_18[]; - static Coding tokenCoding8639_19[]; void TokenFunc8639(x64Operand &operand, int tokenPos); - void TokenFunc8640(x64Operand &operand, int tokenPos); static x64Token tokenBranches8640[]; static x64Token tokenBranches8641[]; static x64Token tokenBranches8642[]; + void TokenFunc8643(x64Operand &operand, int tokenPos); static x64Token tokenBranches8643[]; - static Coding tokenCoding8644_16[]; - static Coding tokenCoding8644_17[]; - static Coding tokenCoding8644_23[]; - static Coding tokenCoding8644_18[]; - static Coding tokenCoding8644_19[]; - void TokenFunc8644(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8644[]; + static Coding tokenCoding8645_16[]; + static Coding tokenCoding8645_17[]; + static Coding tokenCoding8645_23[]; + static Coding tokenCoding8645_18[]; + static Coding tokenCoding8645_19[]; void TokenFunc8645(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8645[]; + void TokenFunc8646(x64Operand &operand, int tokenPos); static x64Token tokenBranches8646[]; static x64Token tokenBranches8647[]; static x64Token tokenBranches8648[]; - static Coding tokenCoding8649_16[]; - static Coding tokenCoding8649_17[]; - static Coding tokenCoding8649_23[]; - static Coding tokenCoding8649_18[]; - static Coding tokenCoding8649_19[]; - void TokenFunc8649(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8650[]; + static x64Token tokenBranches8649[]; + static Coding tokenCoding8650_16[]; + static Coding tokenCoding8650_17[]; + static Coding tokenCoding8650_23[]; + static Coding tokenCoding8650_18[]; + static Coding tokenCoding8650_19[]; + void TokenFunc8650(x64Operand &operand, int tokenPos); + void TokenFunc8651(x64Operand &operand, int tokenPos); static x64Token tokenBranches8651[]; - void TokenFunc8652(x64Operand &operand, int tokenPos); static x64Token tokenBranches8652[]; static x64Token tokenBranches8653[]; - static Coding tokenCoding8654_16[]; - static Coding tokenCoding8654_17[]; - static Coding tokenCoding8654_23[]; - static Coding tokenCoding8654_18[]; - static Coding tokenCoding8654_19[]; - void TokenFunc8654(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8655[]; - void TokenFunc8656(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8654[]; + static Coding tokenCoding8655_16[]; + static Coding tokenCoding8655_17[]; + static Coding tokenCoding8655_23[]; + static Coding tokenCoding8655_18[]; + static Coding tokenCoding8655_19[]; + void TokenFunc8655(x64Operand &operand, int tokenPos); static x64Token tokenBranches8656[]; static x64Token tokenBranches8657[]; + void TokenFunc8658(x64Operand &operand, int tokenPos); static x64Token tokenBranches8658[]; static x64Token tokenBranches8659[]; static Coding tokenCoding8660_16[]; static Coding tokenCoding8660_17[]; static Coding tokenCoding8660_23[]; static Coding tokenCoding8660_18[]; + static Coding tokenCoding8660_19[]; void TokenFunc8660(x64Operand &operand, int tokenPos); static x64Token tokenBranches8661[]; void TokenFunc8662(x64Operand &operand, int tokenPos); @@ -6129,86 +6132,97 @@ class x64Parser : public InstructionParser static Coding tokenCoding8678_17[]; static Coding tokenCoding8678_23[]; static Coding tokenCoding8678_18[]; - static Coding tokenCoding8678_19[]; void TokenFunc8678(x64Operand &operand, int tokenPos); - void TokenFunc8679(x64Operand &operand, int tokenPos); static x64Token tokenBranches8679[]; + void TokenFunc8680(x64Operand &operand, int tokenPos); static x64Token tokenBranches8680[]; static x64Token tokenBranches8681[]; static x64Token tokenBranches8682[]; - static Coding tokenCoding8683_16[]; - static Coding tokenCoding8683_17[]; - static Coding tokenCoding8683_23[]; - static Coding tokenCoding8683_18[]; - static Coding tokenCoding8683_19[]; - void TokenFunc8683(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8683[]; + static Coding tokenCoding8684_16[]; + static Coding tokenCoding8684_17[]; + static Coding tokenCoding8684_23[]; + static Coding tokenCoding8684_18[]; + static Coding tokenCoding8684_19[]; + void TokenFunc8684(x64Operand &operand, int tokenPos); + void TokenFunc8685(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8685[]; static x64Token tokenBranches8686[]; static x64Token tokenBranches8687[]; - static Coding tokenCoding8688_16[]; - static Coding tokenCoding8688_17[]; - static Coding tokenCoding8688_23[]; - static Coding tokenCoding8688_18[]; - static Coding tokenCoding8688_19[]; - void TokenFunc8688(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8691[]; + static x64Token tokenBranches8688[]; + static Coding tokenCoding8689_16[]; + static Coding tokenCoding8689_17[]; + static Coding tokenCoding8689_23[]; + static Coding tokenCoding8689_18[]; + static Coding tokenCoding8689_19[]; + void TokenFunc8689(x64Operand &operand, int tokenPos); static x64Token tokenBranches8692[]; - static Coding tokenCoding8693_16[]; - static Coding tokenCoding8693_17[]; - static Coding tokenCoding8693_23[]; - static Coding tokenCoding8693_18[]; - static Coding tokenCoding8693_19[]; - void TokenFunc8693(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8699[]; - void TokenFunc8700(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8700[]; - static x64Token tokenBranches8701[]; - static Coding tokenCoding8702_16[]; - static Coding tokenCoding8702_17[]; - static Coding tokenCoding8702_23[]; - static Coding tokenCoding8702_18[]; - void TokenFunc8702(x64Operand &operand, int tokenPos); - void TokenFunc8703(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8703[]; - static x64Token tokenBranches8704[]; - static Coding tokenCoding8705_16[]; - static Coding tokenCoding8705_17[]; - static Coding tokenCoding8705_23[]; - static Coding tokenCoding8705_18[]; - void TokenFunc8705(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8693[]; + static Coding tokenCoding8694_16[]; + static Coding tokenCoding8694_17[]; + static Coding tokenCoding8694_23[]; + static Coding tokenCoding8694_18[]; + static Coding tokenCoding8694_19[]; + void TokenFunc8694(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8697[]; + static x64Token tokenBranches8698[]; + static Coding tokenCoding8699_16[]; + static Coding tokenCoding8699_17[]; + static Coding tokenCoding8699_23[]; + static Coding tokenCoding8699_18[]; + static Coding tokenCoding8699_19[]; + void TokenFunc8699(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8705[]; + void TokenFunc8706(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8706[]; + static x64Token tokenBranches8707[]; static Coding tokenCoding8708_16[]; static Coding tokenCoding8708_17[]; static Coding tokenCoding8708_23[]; static Coding tokenCoding8708_18[]; void TokenFunc8708(x64Operand &operand, int tokenPos); + void TokenFunc8709(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8709[]; + static x64Token tokenBranches8710[]; static Coding tokenCoding8711_16[]; static Coding tokenCoding8711_17[]; static Coding tokenCoding8711_23[]; static Coding tokenCoding8711_18[]; void TokenFunc8711(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8720[]; - void TokenFunc8721(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8721[]; - static x64Token tokenBranches8722[]; - static x64Token tokenBranches8723[]; - static x64Token tokenBranches8724[]; - static Coding tokenCoding8725_16[]; - static Coding tokenCoding8725_17[]; - static Coding tokenCoding8725_18[]; - void TokenFunc8725(x64Operand &operand, int tokenPos); + static Coding tokenCoding8714_16[]; + static Coding tokenCoding8714_17[]; + static Coding tokenCoding8714_23[]; + static Coding tokenCoding8714_18[]; + void TokenFunc8714(x64Operand &operand, int tokenPos); + static Coding tokenCoding8717_16[]; + static Coding tokenCoding8717_17[]; + static Coding tokenCoding8717_23[]; + static Coding tokenCoding8717_18[]; + void TokenFunc8717(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8726[]; + void TokenFunc8727(x64Operand &operand, int tokenPos); static x64Token tokenBranches8727[]; static x64Token tokenBranches8728[]; static x64Token tokenBranches8729[]; - static Coding tokenCoding8730_16[]; - static Coding tokenCoding8730_17[]; - static Coding tokenCoding8730_18[]; - void TokenFunc8730(x64Operand &operand, int tokenPos); - static x64Token tokenBranches8736[]; - static x64Token tokenBranches8737[]; - static x64Token tokenBranches8738[]; - static Coding tokenCoding8739_16[]; - static Coding tokenCoding8739_17[]; - static Coding tokenCoding8739_18[]; - void TokenFunc8739(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8730[]; + static Coding tokenCoding8731_16[]; + static Coding tokenCoding8731_17[]; + static Coding tokenCoding8731_18[]; + void TokenFunc8731(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8733[]; + static x64Token tokenBranches8734[]; + static x64Token tokenBranches8735[]; + static Coding tokenCoding8736_16[]; + static Coding tokenCoding8736_17[]; + static Coding tokenCoding8736_18[]; + void TokenFunc8736(x64Operand &operand, int tokenPos); + static x64Token tokenBranches8742[]; + static x64Token tokenBranches8743[]; + static x64Token tokenBranches8744[]; + static Coding tokenCoding8745_16[]; + static Coding tokenCoding8745_17[]; + static Coding tokenCoding8745_18[]; + void TokenFunc8745(x64Operand &operand, int tokenPos); asmError Opcode0(x64Operand &operand); asmError Opcode1(x64Operand &operand); @@ -6381,49 +6395,45 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings96_19[]; asmError Opcode96(x64Operand &operand); asmError Opcode97(x64Operand &operand); - static Coding OpcodeCodings98_19[]; asmError Opcode98(x64Operand &operand); - static Coding OpcodeCodings99_19[]; asmError Opcode99(x64Operand &operand); static Coding OpcodeCodings100_19[]; asmError Opcode100(x64Operand &operand); static Coding OpcodeCodings101_19[]; asmError Opcode101(x64Operand &operand); - static Coding OpcodeCodings102_18[]; static Coding OpcodeCodings102_19[]; asmError Opcode102(x64Operand &operand); - static Coding OpcodeCodings103_18[]; + static Coding OpcodeCodings103_19[]; asmError Opcode103(x64Operand &operand); + static Coding OpcodeCodings104_18[]; + static Coding OpcodeCodings104_19[]; asmError Opcode104(x64Operand &operand); + static Coding OpcodeCodings105_18[]; asmError Opcode105(x64Operand &operand); - static Coding OpcodeCodings106_19[]; asmError Opcode106(x64Operand &operand); - static Coding OpcodeCodings107_19[]; asmError Opcode107(x64Operand &operand); - static Coding OpcodeCodings108_18[]; - static Coding OpcodeCodings108_39[]; - static Coding OpcodeCodings108_36[]; + static Coding OpcodeCodings108_19[]; asmError Opcode108(x64Operand &operand); - static Coding OpcodeCodings109_18[]; static Coding OpcodeCodings109_19[]; asmError Opcode109(x64Operand &operand); static Coding OpcodeCodings110_18[]; - static Coding OpcodeCodings110_19[]; + static Coding OpcodeCodings110_39[]; + static Coding OpcodeCodings110_36[]; asmError Opcode110(x64Operand &operand); static Coding OpcodeCodings111_18[]; static Coding OpcodeCodings111_19[]; asmError Opcode111(x64Operand &operand); + static Coding OpcodeCodings112_18[]; static Coding OpcodeCodings112_19[]; asmError Opcode112(x64Operand &operand); + static Coding OpcodeCodings113_18[]; static Coding OpcodeCodings113_19[]; asmError Opcode113(x64Operand &operand); static Coding OpcodeCodings114_19[]; asmError Opcode114(x64Operand &operand); - static Coding OpcodeCodings115_18[]; - static Coding OpcodeCodings115_36[]; + static Coding OpcodeCodings115_19[]; asmError Opcode115(x64Operand &operand); - static Coding OpcodeCodings116_18[]; - static Coding OpcodeCodings116_36[]; + static Coding OpcodeCodings116_19[]; asmError Opcode116(x64Operand &operand); static Coding OpcodeCodings117_18[]; static Coding OpcodeCodings117_36[]; @@ -6455,19 +6465,18 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings126_18[]; static Coding OpcodeCodings126_36[]; asmError Opcode126(x64Operand &operand); - static Coding OpcodeCodings127_19[]; + static Coding OpcodeCodings127_18[]; + static Coding OpcodeCodings127_36[]; asmError Opcode127(x64Operand &operand); - static Coding OpcodeCodings128_19[]; + static Coding OpcodeCodings128_18[]; + static Coding OpcodeCodings128_36[]; asmError Opcode128(x64Operand &operand); static Coding OpcodeCodings129_19[]; asmError Opcode129(x64Operand &operand); static Coding OpcodeCodings130_19[]; asmError Opcode130(x64Operand &operand); - static Coding OpcodeCodings131_18[]; - static Coding OpcodeCodings131_39[]; - static Coding OpcodeCodings131_36[]; + static Coding OpcodeCodings131_19[]; asmError Opcode131(x64Operand &operand); - static Coding OpcodeCodings132_18[]; static Coding OpcodeCodings132_19[]; asmError Opcode132(x64Operand &operand); static Coding OpcodeCodings133_18[]; @@ -6477,15 +6486,16 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings134_18[]; static Coding OpcodeCodings134_19[]; asmError Opcode134(x64Operand &operand); - static Coding OpcodeCodings135_19[]; + static Coding OpcodeCodings135_18[]; + static Coding OpcodeCodings135_39[]; + static Coding OpcodeCodings135_36[]; asmError Opcode135(x64Operand &operand); + static Coding OpcodeCodings136_18[]; + static Coding OpcodeCodings136_19[]; asmError Opcode136(x64Operand &operand); + static Coding OpcodeCodings137_19[]; asmError Opcode137(x64Operand &operand); - static Coding OpcodeCodings138_18[]; - static Coding OpcodeCodings138_36[]; asmError Opcode138(x64Operand &operand); - static Coding OpcodeCodings139_18[]; - static Coding OpcodeCodings139_36[]; asmError Opcode139(x64Operand &operand); static Coding OpcodeCodings140_18[]; static Coding OpcodeCodings140_36[]; @@ -6502,17 +6512,17 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings144_18[]; static Coding OpcodeCodings144_36[]; asmError Opcode144(x64Operand &operand); - static Coding OpcodeCodings145_19[]; + static Coding OpcodeCodings145_18[]; + static Coding OpcodeCodings145_36[]; asmError Opcode145(x64Operand &operand); - static Coding OpcodeCodings146_19[]; + static Coding OpcodeCodings146_18[]; + static Coding OpcodeCodings146_36[]; asmError Opcode146(x64Operand &operand); static Coding OpcodeCodings147_19[]; asmError Opcode147(x64Operand &operand); - static Coding OpcodeCodings148_18[]; - static Coding OpcodeCodings148_36[]; + static Coding OpcodeCodings148_19[]; asmError Opcode148(x64Operand &operand); - static Coding OpcodeCodings149_18[]; - static Coding OpcodeCodings149_36[]; + static Coding OpcodeCodings149_19[]; asmError Opcode149(x64Operand &operand); static Coding OpcodeCodings150_18[]; static Coding OpcodeCodings150_36[]; @@ -6520,14 +6530,16 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings151_18[]; static Coding OpcodeCodings151_36[]; asmError Opcode151(x64Operand &operand); + static Coding OpcodeCodings152_18[]; + static Coding OpcodeCodings152_36[]; asmError Opcode152(x64Operand &operand); - static Coding OpcodeCodings153_19[]; + static Coding OpcodeCodings153_18[]; + static Coding OpcodeCodings153_36[]; asmError Opcode153(x64Operand &operand); asmError Opcode154(x64Operand &operand); + static Coding OpcodeCodings155_19[]; asmError Opcode155(x64Operand &operand); - static Coding OpcodeCodings156_19[]; asmError Opcode156(x64Operand &operand); - static Coding OpcodeCodings157_19[]; asmError Opcode157(x64Operand &operand); static Coding OpcodeCodings158_19[]; asmError Opcode158(x64Operand &operand); @@ -6537,19 +6549,19 @@ class x64Parser : public InstructionParser asmError Opcode160(x64Operand &operand); static Coding OpcodeCodings161_19[]; asmError Opcode161(x64Operand &operand); - static Coding OpcodeCodings162_18[]; - static Coding OpcodeCodings162_39[]; - static Coding OpcodeCodings162_36[]; + static Coding OpcodeCodings162_19[]; asmError Opcode162(x64Operand &operand); - static Coding OpcodeCodings163_18[]; static Coding OpcodeCodings163_19[]; asmError Opcode163(x64Operand &operand); - static Coding OpcodeCodings164_19[]; + static Coding OpcodeCodings164_18[]; + static Coding OpcodeCodings164_39[]; + static Coding OpcodeCodings164_36[]; asmError Opcode164(x64Operand &operand); + static Coding OpcodeCodings165_18[]; + static Coding OpcodeCodings165_19[]; asmError Opcode165(x64Operand &operand); static Coding OpcodeCodings166_19[]; asmError Opcode166(x64Operand &operand); - static Coding OpcodeCodings167_19[]; asmError Opcode167(x64Operand &operand); static Coding OpcodeCodings168_19[]; asmError Opcode168(x64Operand &operand); @@ -6557,11 +6569,11 @@ class x64Parser : public InstructionParser asmError Opcode169(x64Operand &operand); static Coding OpcodeCodings170_19[]; asmError Opcode170(x64Operand &operand); + static Coding OpcodeCodings171_19[]; asmError Opcode171(x64Operand &operand); + static Coding OpcodeCodings172_19[]; asmError Opcode172(x64Operand &operand); - static Coding OpcodeCodings173_19[]; asmError Opcode173(x64Operand &operand); - static Coding OpcodeCodings174_19[]; asmError Opcode174(x64Operand &operand); static Coding OpcodeCodings175_19[]; asmError Opcode175(x64Operand &operand); @@ -6569,7 +6581,9 @@ class x64Parser : public InstructionParser asmError Opcode176(x64Operand &operand); static Coding OpcodeCodings177_19[]; asmError Opcode177(x64Operand &operand); + static Coding OpcodeCodings178_19[]; asmError Opcode178(x64Operand &operand); + static Coding OpcodeCodings179_19[]; asmError Opcode179(x64Operand &operand); asmError Opcode180(x64Operand &operand); asmError Opcode181(x64Operand &operand); @@ -6577,12 +6591,7 @@ class x64Parser : public InstructionParser asmError Opcode183(x64Operand &operand); asmError Opcode184(x64Operand &operand); asmError Opcode185(x64Operand &operand); - static Coding OpcodeCodings186_18[]; - static Coding OpcodeCodings186_39[]; - static Coding OpcodeCodings186_36[]; asmError Opcode186(x64Operand &operand); - static Coding OpcodeCodings187_18[]; - static Coding OpcodeCodings187_19[]; asmError Opcode187(x64Operand &operand); static Coding OpcodeCodings188_18[]; static Coding OpcodeCodings188_39[]; @@ -6591,40 +6600,43 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings189_18[]; static Coding OpcodeCodings189_19[]; asmError Opcode189(x64Operand &operand); - static Coding OpcodeCodings190_19[]; + static Coding OpcodeCodings190_18[]; + static Coding OpcodeCodings190_39[]; + static Coding OpcodeCodings190_36[]; asmError Opcode190(x64Operand &operand); static Coding OpcodeCodings191_18[]; static Coding OpcodeCodings191_19[]; asmError Opcode191(x64Operand &operand); - static Coding OpcodeCodings192_18[]; - static Coding OpcodeCodings192_36[]; + static Coding OpcodeCodings192_19[]; asmError Opcode192(x64Operand &operand); static Coding OpcodeCodings193_18[]; - static Coding OpcodeCodings193_36[]; + static Coding OpcodeCodings193_19[]; asmError Opcode193(x64Operand &operand); static Coding OpcodeCodings194_18[]; - static Coding OpcodeCodings194_19[]; + static Coding OpcodeCodings194_36[]; asmError Opcode194(x64Operand &operand); - static Coding OpcodeCodings195_19[]; + static Coding OpcodeCodings195_18[]; + static Coding OpcodeCodings195_36[]; asmError Opcode195(x64Operand &operand); + static Coding OpcodeCodings196_18[]; static Coding OpcodeCodings196_19[]; asmError Opcode196(x64Operand &operand); static Coding OpcodeCodings197_19[]; asmError Opcode197(x64Operand &operand); - static Coding OpcodeCodings198_18[]; static Coding OpcodeCodings198_19[]; asmError Opcode198(x64Operand &operand); - static Coding OpcodeCodings199_18[]; - static Coding OpcodeCodings199_36[]; + static Coding OpcodeCodings199_19[]; asmError Opcode199(x64Operand &operand); static Coding OpcodeCodings200_18[]; - static Coding OpcodeCodings200_36[]; + static Coding OpcodeCodings200_19[]; asmError Opcode200(x64Operand &operand); + static Coding OpcodeCodings201_18[]; + static Coding OpcodeCodings201_36[]; asmError Opcode201(x64Operand &operand); + static Coding OpcodeCodings202_18[]; + static Coding OpcodeCodings202_36[]; asmError Opcode202(x64Operand &operand); - static Coding OpcodeCodings203_19[]; asmError Opcode203(x64Operand &operand); - static Coding OpcodeCodings204_19[]; asmError Opcode204(x64Operand &operand); static Coding OpcodeCodings205_19[]; asmError Opcode205(x64Operand &operand); @@ -6632,40 +6644,40 @@ class x64Parser : public InstructionParser asmError Opcode206(x64Operand &operand); static Coding OpcodeCodings207_19[]; asmError Opcode207(x64Operand &operand); - static Coding OpcodeCodings208_18[]; + static Coding OpcodeCodings208_19[]; asmError Opcode208(x64Operand &operand); + static Coding OpcodeCodings209_19[]; asmError Opcode209(x64Operand &operand); + static Coding OpcodeCodings210_18[]; asmError Opcode210(x64Operand &operand); asmError Opcode211(x64Operand &operand); - static Coding OpcodeCodings212_19[]; asmError Opcode212(x64Operand &operand); - static Coding OpcodeCodings213_19[]; asmError Opcode213(x64Operand &operand); static Coding OpcodeCodings214_19[]; asmError Opcode214(x64Operand &operand); - static Coding OpcodeCodings215_18[]; static Coding OpcodeCodings215_19[]; asmError Opcode215(x64Operand &operand); + static Coding OpcodeCodings216_19[]; asmError Opcode216(x64Operand &operand); + static Coding OpcodeCodings217_18[]; static Coding OpcodeCodings217_19[]; asmError Opcode217(x64Operand &operand); - static Coding OpcodeCodings218_19[]; asmError Opcode218(x64Operand &operand); static Coding OpcodeCodings219_19[]; asmError Opcode219(x64Operand &operand); static Coding OpcodeCodings220_19[]; asmError Opcode220(x64Operand &operand); + static Coding OpcodeCodings221_19[]; asmError Opcode221(x64Operand &operand); static Coding OpcodeCodings222_19[]; asmError Opcode222(x64Operand &operand); - static Coding OpcodeCodings223_19[]; asmError Opcode223(x64Operand &operand); + static Coding OpcodeCodings224_19[]; asmError Opcode224(x64Operand &operand); static Coding OpcodeCodings225_19[]; asmError Opcode225(x64Operand &operand); - static Coding OpcodeCodings226_38[]; asmError Opcode226(x64Operand &operand); - static Coding OpcodeCodings227_38[]; + static Coding OpcodeCodings227_19[]; asmError Opcode227(x64Operand &operand); static Coding OpcodeCodings228_38[]; asmError Opcode228(x64Operand &operand); @@ -6673,11 +6685,11 @@ class x64Parser : public InstructionParser asmError Opcode229(x64Operand &operand); static Coding OpcodeCodings230_38[]; asmError Opcode230(x64Operand &operand); + static Coding OpcodeCodings231_38[]; asmError Opcode231(x64Operand &operand); + static Coding OpcodeCodings232_38[]; asmError Opcode232(x64Operand &operand); - static Coding OpcodeCodings233_38[]; asmError Opcode233(x64Operand &operand); - static Coding OpcodeCodings234_38[]; asmError Opcode234(x64Operand &operand); static Coding OpcodeCodings235_38[]; asmError Opcode235(x64Operand &operand); @@ -6685,10 +6697,10 @@ class x64Parser : public InstructionParser asmError Opcode236(x64Operand &operand); static Coding OpcodeCodings237_38[]; asmError Opcode237(x64Operand &operand); + static Coding OpcodeCodings238_38[]; asmError Opcode238(x64Operand &operand); static Coding OpcodeCodings239_38[]; asmError Opcode239(x64Operand &operand); - static Coding OpcodeCodings240_38[]; asmError Opcode240(x64Operand &operand); static Coding OpcodeCodings241_38[]; asmError Opcode241(x64Operand &operand); @@ -6726,15 +6738,15 @@ class x64Parser : public InstructionParser asmError Opcode257(x64Operand &operand); static Coding OpcodeCodings258_38[]; asmError Opcode258(x64Operand &operand); - static Coding OpcodeCodings259_19[]; + static Coding OpcodeCodings259_38[]; asmError Opcode259(x64Operand &operand); - static Coding OpcodeCodings260_36[]; + static Coding OpcodeCodings260_38[]; asmError Opcode260(x64Operand &operand); - static Coding OpcodeCodings261_36[]; + static Coding OpcodeCodings261_19[]; asmError Opcode261(x64Operand &operand); static Coding OpcodeCodings262_36[]; asmError Opcode262(x64Operand &operand); - static Coding OpcodeCodings263_19[]; + static Coding OpcodeCodings263_36[]; asmError Opcode263(x64Operand &operand); static Coding OpcodeCodings264_36[]; asmError Opcode264(x64Operand &operand); @@ -6742,7 +6754,6 @@ class x64Parser : public InstructionParser asmError Opcode265(x64Operand &operand); static Coding OpcodeCodings266_36[]; asmError Opcode266(x64Operand &operand); - static Coding OpcodeCodings267_18[]; static Coding OpcodeCodings267_19[]; asmError Opcode267(x64Operand &operand); static Coding OpcodeCodings268_36[]; @@ -6750,93 +6761,94 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings269_18[]; static Coding OpcodeCodings269_19[]; asmError Opcode269(x64Operand &operand); - static Coding OpcodeCodings270_18[]; - static Coding OpcodeCodings270_19[]; + static Coding OpcodeCodings270_36[]; asmError Opcode270(x64Operand &operand); static Coding OpcodeCodings271_18[]; static Coding OpcodeCodings271_19[]; asmError Opcode271(x64Operand &operand); + static Coding OpcodeCodings272_18[]; + static Coding OpcodeCodings272_19[]; asmError Opcode272(x64Operand &operand); + static Coding OpcodeCodings273_18[]; static Coding OpcodeCodings273_19[]; asmError Opcode273(x64Operand &operand); - static Coding OpcodeCodings274_19[]; asmError Opcode274(x64Operand &operand); static Coding OpcodeCodings275_19[]; asmError Opcode275(x64Operand &operand); + static Coding OpcodeCodings276_19[]; asmError Opcode276(x64Operand &operand); + static Coding OpcodeCodings277_19[]; asmError Opcode277(x64Operand &operand); asmError Opcode278(x64Operand &operand); asmError Opcode279(x64Operand &operand); asmError Opcode280(x64Operand &operand); asmError Opcode281(x64Operand &operand); - static Coding OpcodeCodings282_36[]; asmError Opcode282(x64Operand &operand); - static Coding OpcodeCodings283_36[]; asmError Opcode283(x64Operand &operand); - static Coding OpcodeCodings284_18[]; - static Coding OpcodeCodings284_19[]; + static Coding OpcodeCodings284_36[]; asmError Opcode284(x64Operand &operand); + static Coding OpcodeCodings285_36[]; asmError Opcode285(x64Operand &operand); + static Coding OpcodeCodings286_18[]; + static Coding OpcodeCodings286_19[]; asmError Opcode286(x64Operand &operand); - static Coding OpcodeCodings287_36[]; asmError Opcode287(x64Operand &operand); - static Coding OpcodeCodings288_19[]; asmError Opcode288(x64Operand &operand); - static Coding OpcodeCodings289_19[]; + static Coding OpcodeCodings289_36[]; asmError Opcode289(x64Operand &operand); + static Coding OpcodeCodings290_19[]; asmError Opcode290(x64Operand &operand); + static Coding OpcodeCodings291_19[]; asmError Opcode291(x64Operand &operand); - static Coding OpcodeCodings292_36[]; asmError Opcode292(x64Operand &operand); - static Coding OpcodeCodings293_36[]; asmError Opcode293(x64Operand &operand); + static Coding OpcodeCodings294_36[]; asmError Opcode294(x64Operand &operand); - static Coding OpcodeCodings295_18[]; + static Coding OpcodeCodings295_36[]; asmError Opcode295(x64Operand &operand); - static Coding OpcodeCodings296_18[]; asmError Opcode296(x64Operand &operand); - static Coding OpcodeCodings297_19[]; + static Coding OpcodeCodings297_18[]; asmError Opcode297(x64Operand &operand); static Coding OpcodeCodings298_18[]; asmError Opcode298(x64Operand &operand); - static Coding OpcodeCodings299_18[]; - static Coding OpcodeCodings299_36[]; - static Coding OpcodeCodings299_37[]; + static Coding OpcodeCodings299_19[]; asmError Opcode299(x64Operand &operand); + static Coding OpcodeCodings300_18[]; asmError Opcode300(x64Operand &operand); + static Coding OpcodeCodings301_18[]; + static Coding OpcodeCodings301_36[]; + static Coding OpcodeCodings301_37[]; asmError Opcode301(x64Operand &operand); - static Coding OpcodeCodings302_19[]; asmError Opcode302(x64Operand &operand); - static Coding OpcodeCodings303_19[]; asmError Opcode303(x64Operand &operand); static Coding OpcodeCodings304_19[]; asmError Opcode304(x64Operand &operand); + static Coding OpcodeCodings305_19[]; asmError Opcode305(x64Operand &operand); static Coding OpcodeCodings306_19[]; asmError Opcode306(x64Operand &operand); - static Coding OpcodeCodings307_19[]; asmError Opcode307(x64Operand &operand); static Coding OpcodeCodings308_19[]; asmError Opcode308(x64Operand &operand); - static Coding OpcodeCodings309_23[]; - static Coding OpcodeCodings309_36[]; + static Coding OpcodeCodings309_19[]; asmError Opcode309(x64Operand &operand); static Coding OpcodeCodings310_19[]; asmError Opcode310(x64Operand &operand); - static Coding OpcodeCodings311_19[]; + static Coding OpcodeCodings311_23[]; + static Coding OpcodeCodings311_36[]; asmError Opcode311(x64Operand &operand); static Coding OpcodeCodings312_19[]; asmError Opcode312(x64Operand &operand); static Coding OpcodeCodings313_19[]; asmError Opcode313(x64Operand &operand); + static Coding OpcodeCodings314_19[]; asmError Opcode314(x64Operand &operand); + static Coding OpcodeCodings315_19[]; asmError Opcode315(x64Operand &operand); asmError Opcode316(x64Operand &operand); asmError Opcode317(x64Operand &operand); asmError Opcode318(x64Operand &operand); - static Coding OpcodeCodings319_19[]; asmError Opcode319(x64Operand &operand); - static Coding OpcodeCodings320_19[]; asmError Opcode320(x64Operand &operand); static Coding OpcodeCodings321_19[]; asmError Opcode321(x64Operand &operand); @@ -6848,45 +6860,45 @@ class x64Parser : public InstructionParser asmError Opcode324(x64Operand &operand); static Coding OpcodeCodings325_19[]; asmError Opcode325(x64Operand &operand); - static Coding OpcodeCodings326_18[]; + static Coding OpcodeCodings326_19[]; asmError Opcode326(x64Operand &operand); - static Coding OpcodeCodings327_18[]; + static Coding OpcodeCodings327_19[]; asmError Opcode327(x64Operand &operand); - static Coding OpcodeCodings328_19[]; + static Coding OpcodeCodings328_18[]; asmError Opcode328(x64Operand &operand); - static Coding OpcodeCodings329_19[]; + static Coding OpcodeCodings329_18[]; asmError Opcode329(x64Operand &operand); static Coding OpcodeCodings330_19[]; asmError Opcode330(x64Operand &operand); + static Coding OpcodeCodings331_19[]; asmError Opcode331(x64Operand &operand); + static Coding OpcodeCodings332_19[]; asmError Opcode332(x64Operand &operand); - static Coding OpcodeCodings333_18[]; asmError Opcode333(x64Operand &operand); - static Coding OpcodeCodings334_18[]; asmError Opcode334(x64Operand &operand); - static Coding OpcodeCodings335_19[]; + static Coding OpcodeCodings335_18[]; asmError Opcode335(x64Operand &operand); - static Coding OpcodeCodings336_19[]; + static Coding OpcodeCodings336_18[]; asmError Opcode336(x64Operand &operand); - static Coding OpcodeCodings337_18[]; + static Coding OpcodeCodings337_19[]; asmError Opcode337(x64Operand &operand); - static Coding OpcodeCodings338_18[]; + static Coding OpcodeCodings338_19[]; asmError Opcode338(x64Operand &operand); static Coding OpcodeCodings339_18[]; - static Coding OpcodeCodings339_36[]; - static Coding OpcodeCodings339_37[]; asmError Opcode339(x64Operand &operand); + static Coding OpcodeCodings340_18[]; asmError Opcode340(x64Operand &operand); - static Coding OpcodeCodings341_19[]; + static Coding OpcodeCodings341_18[]; + static Coding OpcodeCodings341_36[]; + static Coding OpcodeCodings341_37[]; asmError Opcode341(x64Operand &operand); - static Coding OpcodeCodings342_19[]; asmError Opcode342(x64Operand &operand); static Coding OpcodeCodings343_19[]; asmError Opcode343(x64Operand &operand); + static Coding OpcodeCodings344_19[]; asmError Opcode344(x64Operand &operand); - static Coding OpcodeCodings345_38[]; + static Coding OpcodeCodings345_19[]; asmError Opcode345(x64Operand &operand); - static Coding OpcodeCodings346_38[]; asmError Opcode346(x64Operand &operand); static Coding OpcodeCodings347_38[]; asmError Opcode347(x64Operand &operand); @@ -6944,91 +6956,89 @@ class x64Parser : public InstructionParser asmError Opcode373(x64Operand &operand); static Coding OpcodeCodings374_38[]; asmError Opcode374(x64Operand &operand); - static Coding OpcodeCodings375_19[]; + static Coding OpcodeCodings375_38[]; asmError Opcode375(x64Operand &operand); - static Coding OpcodeCodings376_18[]; - static Coding OpcodeCodings376_19[]; + static Coding OpcodeCodings376_38[]; asmError Opcode376(x64Operand &operand); - static Coding OpcodeCodings377_18[]; + static Coding OpcodeCodings377_19[]; asmError Opcode377(x64Operand &operand); - static Coding OpcodeCodings378_36[]; + static Coding OpcodeCodings378_18[]; + static Coding OpcodeCodings378_19[]; asmError Opcode378(x64Operand &operand); static Coding OpcodeCodings379_18[]; asmError Opcode379(x64Operand &operand); static Coding OpcodeCodings380_36[]; asmError Opcode380(x64Operand &operand); static Coding OpcodeCodings381_18[]; - static Coding OpcodeCodings381_19[]; asmError Opcode381(x64Operand &operand); - static Coding OpcodeCodings382_18[]; - static Coding OpcodeCodings382_19[]; + static Coding OpcodeCodings382_36[]; asmError Opcode382(x64Operand &operand); static Coding OpcodeCodings383_18[]; static Coding OpcodeCodings383_19[]; asmError Opcode383(x64Operand &operand); + static Coding OpcodeCodings384_18[]; static Coding OpcodeCodings384_19[]; asmError Opcode384(x64Operand &operand); + static Coding OpcodeCodings385_18[]; static Coding OpcodeCodings385_19[]; asmError Opcode385(x64Operand &operand); static Coding OpcodeCodings386_19[]; asmError Opcode386(x64Operand &operand); + static Coding OpcodeCodings387_19[]; asmError Opcode387(x64Operand &operand); static Coding OpcodeCodings388_19[]; asmError Opcode388(x64Operand &operand); - static Coding OpcodeCodings389_19[]; asmError Opcode389(x64Operand &operand); static Coding OpcodeCodings390_19[]; asmError Opcode390(x64Operand &operand); + static Coding OpcodeCodings391_19[]; asmError Opcode391(x64Operand &operand); - static Coding OpcodeCodings392_18[]; static Coding OpcodeCodings392_19[]; asmError Opcode392(x64Operand &operand); - static Coding OpcodeCodings393_18[]; - static Coding OpcodeCodings393_36[]; - static Coding OpcodeCodings393_37[]; asmError Opcode393(x64Operand &operand); + static Coding OpcodeCodings394_18[]; static Coding OpcodeCodings394_19[]; asmError Opcode394(x64Operand &operand); - static Coding OpcodeCodings395_19[]; + static Coding OpcodeCodings395_18[]; + static Coding OpcodeCodings395_36[]; + static Coding OpcodeCodings395_37[]; asmError Opcode395(x64Operand &operand); static Coding OpcodeCodings396_19[]; asmError Opcode396(x64Operand &operand); static Coding OpcodeCodings397_19[]; asmError Opcode397(x64Operand &operand); + static Coding OpcodeCodings398_19[]; asmError Opcode398(x64Operand &operand); static Coding OpcodeCodings399_19[]; asmError Opcode399(x64Operand &operand); - static Coding OpcodeCodings400_18[]; - static Coding OpcodeCodings400_19[]; asmError Opcode400(x64Operand &operand); - static Coding OpcodeCodings401_18[]; static Coding OpcodeCodings401_19[]; asmError Opcode401(x64Operand &operand); + static Coding OpcodeCodings402_18[]; static Coding OpcodeCodings402_19[]; asmError Opcode402(x64Operand &operand); + static Coding OpcodeCodings403_18[]; static Coding OpcodeCodings403_19[]; asmError Opcode403(x64Operand &operand); static Coding OpcodeCodings404_19[]; asmError Opcode404(x64Operand &operand); + static Coding OpcodeCodings405_19[]; asmError Opcode405(x64Operand &operand); + static Coding OpcodeCodings406_19[]; asmError Opcode406(x64Operand &operand); asmError Opcode407(x64Operand &operand); - static Coding OpcodeCodings408_19[]; asmError Opcode408(x64Operand &operand); - static Coding OpcodeCodings409_18[]; - static Coding OpcodeCodings409_36[]; - static Coding OpcodeCodings409_37[]; asmError Opcode409(x64Operand &operand); + static Coding OpcodeCodings410_19[]; asmError Opcode410(x64Operand &operand); + static Coding OpcodeCodings411_18[]; + static Coding OpcodeCodings411_36[]; + static Coding OpcodeCodings411_37[]; asmError Opcode411(x64Operand &operand); asmError Opcode412(x64Operand &operand); asmError Opcode413(x64Operand &operand); - static Coding OpcodeCodings414_19[]; asmError Opcode414(x64Operand &operand); - static Coding OpcodeCodings415_23[]; - static Coding OpcodeCodings415_19[]; asmError Opcode415(x64Operand &operand); - static Coding OpcodeCodings416_23[]; static Coding OpcodeCodings416_19[]; asmError Opcode416(x64Operand &operand); static Coding OpcodeCodings417_23[]; @@ -7169,13 +7179,13 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings462_23[]; static Coding OpcodeCodings462_19[]; asmError Opcode462(x64Operand &operand); + static Coding OpcodeCodings463_23[]; + static Coding OpcodeCodings463_19[]; asmError Opcode463(x64Operand &operand); + static Coding OpcodeCodings464_23[]; + static Coding OpcodeCodings464_19[]; asmError Opcode464(x64Operand &operand); - static Coding OpcodeCodings465_23[]; - static Coding OpcodeCodings465_19[]; asmError Opcode465(x64Operand &operand); - static Coding OpcodeCodings466_23[]; - static Coding OpcodeCodings466_19[]; asmError Opcode466(x64Operand &operand); static Coding OpcodeCodings467_23[]; static Coding OpcodeCodings467_19[]; @@ -7183,14 +7193,14 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings468_23[]; static Coding OpcodeCodings468_19[]; asmError Opcode468(x64Operand &operand); + static Coding OpcodeCodings469_23[]; static Coding OpcodeCodings469_19[]; asmError Opcode469(x64Operand &operand); + static Coding OpcodeCodings470_23[]; static Coding OpcodeCodings470_19[]; asmError Opcode470(x64Operand &operand); - static Coding OpcodeCodings471_23[]; static Coding OpcodeCodings471_19[]; asmError Opcode471(x64Operand &operand); - static Coding OpcodeCodings472_23[]; static Coding OpcodeCodings472_19[]; asmError Opcode472(x64Operand &operand); static Coding OpcodeCodings473_23[]; @@ -7199,75 +7209,75 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings474_23[]; static Coding OpcodeCodings474_19[]; asmError Opcode474(x64Operand &operand); + static Coding OpcodeCodings475_23[]; static Coding OpcodeCodings475_19[]; asmError Opcode475(x64Operand &operand); static Coding OpcodeCodings476_23[]; - static Coding OpcodeCodings476_36[]; + static Coding OpcodeCodings476_19[]; asmError Opcode476(x64Operand &operand); - static Coding OpcodeCodings477_23[]; - static Coding OpcodeCodings477_36[]; + static Coding OpcodeCodings477_19[]; asmError Opcode477(x64Operand &operand); + static Coding OpcodeCodings478_23[]; + static Coding OpcodeCodings478_36[]; asmError Opcode478(x64Operand &operand); + static Coding OpcodeCodings479_23[]; + static Coding OpcodeCodings479_36[]; asmError Opcode479(x64Operand &operand); - static Coding OpcodeCodings480_23[]; - static Coding OpcodeCodings480_19[]; asmError Opcode480(x64Operand &operand); - static Coding OpcodeCodings481_23[]; - static Coding OpcodeCodings481_19[]; asmError Opcode481(x64Operand &operand); static Coding OpcodeCodings482_23[]; - static Coding OpcodeCodings482_36[]; + static Coding OpcodeCodings482_19[]; asmError Opcode482(x64Operand &operand); static Coding OpcodeCodings483_23[]; - static Coding OpcodeCodings483_36[]; + static Coding OpcodeCodings483_19[]; asmError Opcode483(x64Operand &operand); + static Coding OpcodeCodings484_23[]; + static Coding OpcodeCodings484_36[]; asmError Opcode484(x64Operand &operand); static Coding OpcodeCodings485_23[]; static Coding OpcodeCodings485_36[]; asmError Opcode485(x64Operand &operand); - static Coding OpcodeCodings486_23[]; - static Coding OpcodeCodings486_36[]; asmError Opcode486(x64Operand &operand); + static Coding OpcodeCodings487_23[]; + static Coding OpcodeCodings487_36[]; asmError Opcode487(x64Operand &operand); static Coding OpcodeCodings488_23[]; static Coding OpcodeCodings488_36[]; asmError Opcode488(x64Operand &operand); - static Coding OpcodeCodings489_23[]; - static Coding OpcodeCodings489_36[]; asmError Opcode489(x64Operand &operand); static Coding OpcodeCodings490_23[]; - static Coding OpcodeCodings490_19[]; + static Coding OpcodeCodings490_36[]; asmError Opcode490(x64Operand &operand); static Coding OpcodeCodings491_23[]; - static Coding OpcodeCodings491_19[]; + static Coding OpcodeCodings491_36[]; asmError Opcode491(x64Operand &operand); + static Coding OpcodeCodings492_23[]; + static Coding OpcodeCodings492_19[]; asmError Opcode492(x64Operand &operand); + static Coding OpcodeCodings493_23[]; static Coding OpcodeCodings493_19[]; asmError Opcode493(x64Operand &operand); asmError Opcode494(x64Operand &operand); + static Coding OpcodeCodings495_19[]; asmError Opcode495(x64Operand &operand); asmError Opcode496(x64Operand &operand); asmError Opcode497(x64Operand &operand); - static Coding OpcodeCodings498_23[]; - static Coding OpcodeCodings498_19[]; asmError Opcode498(x64Operand &operand); - static Coding OpcodeCodings499_23[]; - static Coding OpcodeCodings499_19[]; asmError Opcode499(x64Operand &operand); static Coding OpcodeCodings500_23[]; - static Coding OpcodeCodings500_36[]; + static Coding OpcodeCodings500_19[]; asmError Opcode500(x64Operand &operand); static Coding OpcodeCodings501_23[]; - static Coding OpcodeCodings501_36[]; + static Coding OpcodeCodings501_19[]; asmError Opcode501(x64Operand &operand); static Coding OpcodeCodings502_23[]; static Coding OpcodeCodings502_36[]; asmError Opcode502(x64Operand &operand); static Coding OpcodeCodings503_23[]; - static Coding OpcodeCodings503_19[]; + static Coding OpcodeCodings503_36[]; asmError Opcode503(x64Operand &operand); static Coding OpcodeCodings504_23[]; - static Coding OpcodeCodings504_19[]; + static Coding OpcodeCodings504_36[]; asmError Opcode504(x64Operand &operand); static Coding OpcodeCodings505_23[]; static Coding OpcodeCodings505_19[]; @@ -7284,15 +7294,17 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings509_23[]; static Coding OpcodeCodings509_19[]; asmError Opcode509(x64Operand &operand); + static Coding OpcodeCodings510_23[]; static Coding OpcodeCodings510_19[]; asmError Opcode510(x64Operand &operand); + static Coding OpcodeCodings511_23[]; static Coding OpcodeCodings511_19[]; asmError Opcode511(x64Operand &operand); - static Coding OpcodeCodings512_23[]; static Coding OpcodeCodings512_19[]; asmError Opcode512(x64Operand &operand); static Coding OpcodeCodings513_19[]; asmError Opcode513(x64Operand &operand); + static Coding OpcodeCodings514_23[]; static Coding OpcodeCodings514_19[]; asmError Opcode514(x64Operand &operand); static Coding OpcodeCodings515_19[]; @@ -7315,23 +7327,23 @@ class x64Parser : public InstructionParser asmError Opcode523(x64Operand &operand); static Coding OpcodeCodings524_19[]; asmError Opcode524(x64Operand &operand); - static Coding OpcodeCodings525_23[]; static Coding OpcodeCodings525_19[]; asmError Opcode525(x64Operand &operand); static Coding OpcodeCodings526_19[]; asmError Opcode526(x64Operand &operand); + static Coding OpcodeCodings527_23[]; static Coding OpcodeCodings527_19[]; asmError Opcode527(x64Operand &operand); static Coding OpcodeCodings528_19[]; asmError Opcode528(x64Operand &operand); - static Coding OpcodeCodings529_23[]; static Coding OpcodeCodings529_19[]; asmError Opcode529(x64Operand &operand); - static Coding OpcodeCodings530_23[]; static Coding OpcodeCodings530_19[]; asmError Opcode530(x64Operand &operand); + static Coding OpcodeCodings531_23[]; static Coding OpcodeCodings531_19[]; asmError Opcode531(x64Operand &operand); + static Coding OpcodeCodings532_23[]; static Coding OpcodeCodings532_19[]; asmError Opcode532(x64Operand &operand); static Coding OpcodeCodings533_19[]; @@ -7342,17 +7354,17 @@ class x64Parser : public InstructionParser asmError Opcode535(x64Operand &operand); static Coding OpcodeCodings536_19[]; asmError Opcode536(x64Operand &operand); + static Coding OpcodeCodings537_19[]; asmError Opcode537(x64Operand &operand); static Coding OpcodeCodings538_19[]; asmError Opcode538(x64Operand &operand); - static Coding OpcodeCodings539_19[]; asmError Opcode539(x64Operand &operand); static Coding OpcodeCodings540_19[]; asmError Opcode540(x64Operand &operand); + static Coding OpcodeCodings541_19[]; asmError Opcode541(x64Operand &operand); static Coding OpcodeCodings542_19[]; asmError Opcode542(x64Operand &operand); - static Coding OpcodeCodings543_19[]; asmError Opcode543(x64Operand &operand); static Coding OpcodeCodings544_19[]; asmError Opcode544(x64Operand &operand); @@ -7372,10 +7384,8 @@ class x64Parser : public InstructionParser asmError Opcode551(x64Operand &operand); static Coding OpcodeCodings552_19[]; asmError Opcode552(x64Operand &operand); - static Coding OpcodeCodings553_23[]; static Coding OpcodeCodings553_19[]; asmError Opcode553(x64Operand &operand); - static Coding OpcodeCodings554_23[]; static Coding OpcodeCodings554_19[]; asmError Opcode554(x64Operand &operand); static Coding OpcodeCodings555_23[]; @@ -7384,9 +7394,8 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings556_23[]; static Coding OpcodeCodings556_19[]; asmError Opcode556(x64Operand &operand); - static Coding OpcodeCodings557_39[]; - static Coding OpcodeCodings557_36[]; - static Coding OpcodeCodings557_37[]; + static Coding OpcodeCodings557_23[]; + static Coding OpcodeCodings557_19[]; asmError Opcode557(x64Operand &operand); static Coding OpcodeCodings558_23[]; static Coding OpcodeCodings558_19[]; @@ -7395,9 +7404,8 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings559_36[]; static Coding OpcodeCodings559_37[]; asmError Opcode559(x64Operand &operand); - static Coding OpcodeCodings560_39[]; - static Coding OpcodeCodings560_36[]; - static Coding OpcodeCodings560_37[]; + static Coding OpcodeCodings560_23[]; + static Coding OpcodeCodings560_19[]; asmError Opcode560(x64Operand &operand); static Coding OpcodeCodings561_39[]; static Coding OpcodeCodings561_36[]; @@ -7411,20 +7419,24 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings563_36[]; static Coding OpcodeCodings563_37[]; asmError Opcode563(x64Operand &operand); - static Coding OpcodeCodings564_23[]; - static Coding OpcodeCodings564_19[]; + static Coding OpcodeCodings564_39[]; + static Coding OpcodeCodings564_36[]; + static Coding OpcodeCodings564_37[]; asmError Opcode564(x64Operand &operand); static Coding OpcodeCodings565_39[]; static Coding OpcodeCodings565_36[]; static Coding OpcodeCodings565_37[]; asmError Opcode565(x64Operand &operand); - static Coding OpcodeCodings566_39[]; - static Coding OpcodeCodings566_36[]; - static Coding OpcodeCodings566_37[]; + static Coding OpcodeCodings566_23[]; + static Coding OpcodeCodings566_19[]; asmError Opcode566(x64Operand &operand); - static Coding OpcodeCodings567_19[]; + static Coding OpcodeCodings567_39[]; + static Coding OpcodeCodings567_36[]; + static Coding OpcodeCodings567_37[]; asmError Opcode567(x64Operand &operand); - static Coding OpcodeCodings568_19[]; + static Coding OpcodeCodings568_39[]; + static Coding OpcodeCodings568_36[]; + static Coding OpcodeCodings568_37[]; asmError Opcode568(x64Operand &operand); static Coding OpcodeCodings569_19[]; asmError Opcode569(x64Operand &operand); @@ -7440,26 +7452,24 @@ class x64Parser : public InstructionParser asmError Opcode574(x64Operand &operand); static Coding OpcodeCodings575_19[]; asmError Opcode575(x64Operand &operand); - static Coding OpcodeCodings576_23[]; static Coding OpcodeCodings576_19[]; asmError Opcode576(x64Operand &operand); static Coding OpcodeCodings577_19[]; asmError Opcode577(x64Operand &operand); + static Coding OpcodeCodings578_23[]; static Coding OpcodeCodings578_19[]; asmError Opcode578(x64Operand &operand); static Coding OpcodeCodings579_19[]; asmError Opcode579(x64Operand &operand); - static Coding OpcodeCodings580_23[]; static Coding OpcodeCodings580_19[]; asmError Opcode580(x64Operand &operand); static Coding OpcodeCodings581_19[]; asmError Opcode581(x64Operand &operand); + static Coding OpcodeCodings582_23[]; static Coding OpcodeCodings582_19[]; asmError Opcode582(x64Operand &operand); - static Coding OpcodeCodings583_23[]; static Coding OpcodeCodings583_19[]; asmError Opcode583(x64Operand &operand); - static Coding OpcodeCodings584_23[]; static Coding OpcodeCodings584_19[]; asmError Opcode584(x64Operand &operand); static Coding OpcodeCodings585_23[]; @@ -7534,7 +7544,11 @@ class x64Parser : public InstructionParser static Coding OpcodeCodings608_23[]; static Coding OpcodeCodings608_19[]; asmError Opcode608(x64Operand &operand); + static Coding OpcodeCodings609_23[]; + static Coding OpcodeCodings609_19[]; asmError Opcode609(x64Operand &operand); + static Coding OpcodeCodings610_23[]; + static Coding OpcodeCodings610_19[]; asmError Opcode610(x64Operand &operand); asmError Opcode611(x64Operand &operand); asmError Opcode612(x64Operand &operand); @@ -7546,6 +7560,8 @@ class x64Parser : public InstructionParser asmError Opcode618(x64Operand &operand); asmError Opcode619(x64Operand &operand); asmError Opcode620(x64Operand &operand); + asmError Opcode621(x64Operand &operand); + asmError Opcode622(x64Operand &operand); static Coding Coding1[]; static Coding Coding2[]; @@ -8279,6 +8295,7 @@ class x64Parser : public InstructionParser static Coding Coding730[]; static Coding Coding731[]; static Coding Coding732[]; + static Coding Coding733[]; static Coding *Codings[]; static Coding prefixCoding1[]; diff --git a/src/occ/x64Parser.cpp b/src/occ/x64Parser.cpp index 457accef1..ba731a80e 100644 --- a/src/occ/x64Parser.cpp +++ b/src/occ/x64Parser.cpp @@ -799,530 +799,532 @@ void x64Parser::Init() opcodeTable["cmpxchg8b"] = 94; opcodeTable["cmpxchg16b"] = 95; opcodeTable["cpuid"] = 96; - opcodeTable["cqo"] = 97; - opcodeTable["cwd"] = 98; - opcodeTable["cwde"] = 99; - opcodeTable["daa"] = 100; - opcodeTable["das"] = 101; - opcodeTable["dec"] = 102; - opcodeTable["div"] = 103; - opcodeTable["enter"] = 104; - opcodeTable["esc"] = 105; - opcodeTable["f2xm1"] = 106; - opcodeTable["fabs"] = 107; - opcodeTable["fadd"] = 108; - opcodeTable["faddp"] = 109; - opcodeTable["fbld"] = 110; - opcodeTable["fbstp"] = 111; - opcodeTable["fchs"] = 112; - opcodeTable["fclex"] = 113; - opcodeTable["fnclex"] = 114; - opcodeTable["fcmovb"] = 115; - opcodeTable["fcmovbe"] = 116; - opcodeTable["fcmove"] = 117; - opcodeTable["fcmovnb"] = 118; - opcodeTable["fcmovnbe"] = 119; - opcodeTable["fcmovne"] = 120; - opcodeTable["fcmovnu"] = 121; - opcodeTable["fcmovu"] = 122; - opcodeTable["fcom"] = 123; - opcodeTable["fcomi"] = 124; - opcodeTable["fcomip"] = 125; - opcodeTable["fcomp"] = 126; - opcodeTable["fcompp"] = 127; - opcodeTable["fcos"] = 128; - opcodeTable["fdecstp"] = 129; - opcodeTable["fdisi"] = 130; - opcodeTable["fdiv"] = 131; - opcodeTable["fdivp"] = 132; - opcodeTable["fdivr"] = 133; - opcodeTable["fdivrp"] = 134; - opcodeTable["feni"] = 135; - opcodeTable["ffree"] = 136; - opcodeTable["ffreep"] = 137; - opcodeTable["fiadd"] = 138; - opcodeTable["ficom"] = 139; - opcodeTable["ficomp"] = 140; - opcodeTable["fidiv"] = 141; - opcodeTable["fidivr"] = 142; - opcodeTable["fild"] = 143; - opcodeTable["fimul"] = 144; - opcodeTable["fincstp"] = 145; - opcodeTable["finit"] = 146; - opcodeTable["fninit"] = 147; - opcodeTable["fist"] = 148; - opcodeTable["fistp"] = 149; - opcodeTable["fisub"] = 150; - opcodeTable["fisubr"] = 151; - opcodeTable["fld"] = 152; - opcodeTable["fld1"] = 153; - opcodeTable["fldcw"] = 154; - opcodeTable["fldenv"] = 155; - opcodeTable["fldl2e"] = 156; - opcodeTable["fldl2t"] = 157; - opcodeTable["fldlg2"] = 158; - opcodeTable["fldln2"] = 159; - opcodeTable["fldpi"] = 160; - opcodeTable["fldz"] = 161; - opcodeTable["fmul"] = 162; - opcodeTable["fmulp"] = 163; - opcodeTable["fnop"] = 164; - opcodeTable["fnsave"] = 165; - opcodeTable["fpatan"] = 166; - opcodeTable["fprem"] = 167; - opcodeTable["fprem1"] = 168; - opcodeTable["fptan"] = 169; - opcodeTable["frndint"] = 170; - opcodeTable["frstor"] = 171; - opcodeTable["fsave"] = 172; - opcodeTable["fscale"] = 173; - opcodeTable["fsetpm"] = 174; - opcodeTable["fsin"] = 175; - opcodeTable["fsincos"] = 176; - opcodeTable["fsqrt"] = 177; - opcodeTable["fst"] = 178; - opcodeTable["fstcw"] = 179; - opcodeTable["fnstcw"] = 180; - opcodeTable["fstenv"] = 181; - opcodeTable["fnstenv"] = 182; - opcodeTable["fstp"] = 183; - opcodeTable["fstsw"] = 184; - opcodeTable["fnstsw"] = 185; - opcodeTable["fsub"] = 186; - opcodeTable["fsubp"] = 187; - opcodeTable["fsubr"] = 188; - opcodeTable["fsubrp"] = 189; - opcodeTable["ftst"] = 190; - opcodeTable["fucom"] = 191; - opcodeTable["fucomi"] = 192; - opcodeTable["fucomip"] = 193; - opcodeTable["fucomp"] = 194; - opcodeTable["fucompp"] = 195; - opcodeTable["fwait"] = 196; - opcodeTable["fxam"] = 197; - opcodeTable["fxch"] = 198; - opcodeTable["fxch4"] = 199; - opcodeTable["fxch7"] = 200; - opcodeTable["fxrstor"] = 201; - opcodeTable["fxsave"] = 202; - opcodeTable["fxtract"] = 203; - opcodeTable["fyl2x"] = 204; - opcodeTable["fyl2xp1"] = 205; - opcodeTable["hlt"] = 206; - opcodeTable["icebp"] = 207; - opcodeTable["idiv"] = 208; - opcodeTable["imul"] = 209; - opcodeTable["in"] = 210; - opcodeTable["ins"] = 211; - opcodeTable["insb"] = 212; - opcodeTable["insw"] = 213; - opcodeTable["insd"] = 214; - opcodeTable["inc"] = 215; - opcodeTable["int"] = 216; - opcodeTable["int1"] = 217; - opcodeTable["int3"] = 218; - opcodeTable["into"] = 219; - opcodeTable["invd"] = 220; - opcodeTable["invlpg"] = 221; - opcodeTable["iret"] = 222; - opcodeTable["iretw"] = 223; - opcodeTable["iretd"] = 224; - opcodeTable["iretq"] = 225; - opcodeTable["ja"] = 226; - opcodeTable["jae"] = 227; - opcodeTable["jb"] = 228; - opcodeTable["jbe"] = 229; - opcodeTable["jc"] = 230; - opcodeTable["jcxz"] = 231; - opcodeTable["jecxz"] = 232; - opcodeTable["je"] = 233; - opcodeTable["jg"] = 234; - opcodeTable["jge"] = 235; - opcodeTable["jl"] = 236; - opcodeTable["jle"] = 237; - opcodeTable["jmp"] = 238; - opcodeTable["jna"] = 239; - opcodeTable["jnae"] = 240; - opcodeTable["jnb"] = 241; - opcodeTable["jnbe"] = 242; - opcodeTable["jnc"] = 243; - opcodeTable["jne"] = 244; - opcodeTable["jng"] = 245; - opcodeTable["jnge"] = 246; - opcodeTable["jnl"] = 247; - opcodeTable["jnle"] = 248; - opcodeTable["jno"] = 249; - opcodeTable["jnp"] = 250; - opcodeTable["jns"] = 251; - opcodeTable["jnz"] = 252; - opcodeTable["jo"] = 253; - opcodeTable["jp"] = 254; - opcodeTable["jpe"] = 255; - opcodeTable["jpo"] = 256; - opcodeTable["js"] = 257; - opcodeTable["jz"] = 258; - opcodeTable["lahf"] = 259; - opcodeTable["lar"] = 260; - opcodeTable["lds"] = 261; - opcodeTable["lea"] = 262; - opcodeTable["leave"] = 263; - opcodeTable["les"] = 264; - opcodeTable["lfence"] = 265; - opcodeTable["lfs"] = 266; - opcodeTable["lgdt"] = 267; - opcodeTable["lgs"] = 268; - opcodeTable["lidt"] = 269; - opcodeTable["lldt"] = 270; - opcodeTable["lmsw"] = 271; - opcodeTable["lods"] = 272; - opcodeTable["lodsb"] = 273; - opcodeTable["lodsw"] = 274; - opcodeTable["lodsd"] = 275; - opcodeTable["lodsq"] = 276; - opcodeTable["loop"] = 277; - opcodeTable["loope"] = 278; - opcodeTable["loopne"] = 279; - opcodeTable["loopnz"] = 280; - opcodeTable["loopz"] = 281; - opcodeTable["lsl"] = 282; - opcodeTable["lss"] = 283; - opcodeTable["ltr"] = 284; - opcodeTable["mov"] = 285; - opcodeTable["movs"] = 286; - opcodeTable["movbe"] = 287; - opcodeTable["movsb"] = 288; - opcodeTable["movsw"] = 289; - opcodeTable["movsd"] = 290; - opcodeTable["movsq"] = 291; - opcodeTable["movsx"] = 292; - opcodeTable["movzx"] = 293; - opcodeTable["movsxd"] = 294; - opcodeTable["mul"] = 295; - opcodeTable["neg"] = 296; - opcodeTable["nop"] = 297; - opcodeTable["not"] = 298; - opcodeTable["or"] = 299; - opcodeTable["out"] = 300; - opcodeTable["outs"] = 301; - opcodeTable["outsb"] = 302; - opcodeTable["outsw"] = 303; - opcodeTable["outsd"] = 304; - opcodeTable["pop"] = 305; - opcodeTable["popa"] = 306; - opcodeTable["popaw"] = 307; - opcodeTable["popad"] = 308; - opcodeTable["popcnt"] = 309; - opcodeTable["popf"] = 310; - opcodeTable["popfw"] = 311; - opcodeTable["popfd"] = 312; - opcodeTable["popfq"] = 313; - opcodeTable["prefetchnta"] = 314; - opcodeTable["prefetcht0"] = 315; - opcodeTable["prefetcht1"] = 316; - opcodeTable["prefetcht2"] = 317; - opcodeTable["push"] = 318; - opcodeTable["pusha"] = 319; - opcodeTable["pushaw"] = 320; - opcodeTable["pushad"] = 321; - opcodeTable["pushf"] = 322; - opcodeTable["pushfw"] = 323; - opcodeTable["pushfd"] = 324; - opcodeTable["pushfq"] = 325; - opcodeTable["rcl"] = 326; - opcodeTable["rcr"] = 327; - opcodeTable["rdmsr"] = 328; - opcodeTable["rdpmc"] = 329; - opcodeTable["rdtsc"] = 330; - opcodeTable["ret"] = 331; - opcodeTable["retf"] = 332; - opcodeTable["rol"] = 333; - opcodeTable["ror"] = 334; - opcodeTable["rsm"] = 335; - opcodeTable["sahf"] = 336; - opcodeTable["sal"] = 337; - opcodeTable["sar"] = 338; - opcodeTable["sbb"] = 339; - opcodeTable["scas"] = 340; - opcodeTable["scasb"] = 341; - opcodeTable["scasw"] = 342; - opcodeTable["scasd"] = 343; - opcodeTable["scasq"] = 344; - opcodeTable["seta"] = 345; - opcodeTable["setae"] = 346; - opcodeTable["setb"] = 347; - opcodeTable["setbe"] = 348; - opcodeTable["setc"] = 349; - opcodeTable["sete"] = 350; - opcodeTable["setg"] = 351; - opcodeTable["setge"] = 352; - opcodeTable["setl"] = 353; - opcodeTable["setle"] = 354; - opcodeTable["setna"] = 355; - opcodeTable["setnae"] = 356; - opcodeTable["setnb"] = 357; - opcodeTable["setnbe"] = 358; - opcodeTable["setnc"] = 359; - opcodeTable["setne"] = 360; - opcodeTable["setng"] = 361; - opcodeTable["setnge"] = 362; - opcodeTable["setnl"] = 363; - opcodeTable["setnle"] = 364; - opcodeTable["setno"] = 365; - opcodeTable["setnp"] = 366; - opcodeTable["setns"] = 367; - opcodeTable["setnz"] = 368; - opcodeTable["seto"] = 369; - opcodeTable["setp"] = 370; - opcodeTable["setpe"] = 371; - opcodeTable["setpo"] = 372; - opcodeTable["sets"] = 373; - opcodeTable["setz"] = 374; - opcodeTable["sfence"] = 375; - opcodeTable["sgdt"] = 376; - opcodeTable["shl"] = 377; - opcodeTable["shld"] = 378; - opcodeTable["shr"] = 379; - opcodeTable["shrd"] = 380; - opcodeTable["sidt"] = 381; - opcodeTable["sldt"] = 382; - opcodeTable["smsw"] = 383; - opcodeTable["stc"] = 384; - opcodeTable["std"] = 385; - opcodeTable["sti"] = 386; - opcodeTable["stos"] = 387; - opcodeTable["stosb"] = 388; - opcodeTable["stosw"] = 389; - opcodeTable["stosd"] = 390; - opcodeTable["stosq"] = 391; - opcodeTable["str"] = 392; - opcodeTable["sub"] = 393; - opcodeTable["syscall"] = 394; - opcodeTable["sysenter"] = 395; - opcodeTable["sysexit"] = 396; - opcodeTable["sysret"] = 397; - opcodeTable["test"] = 398; - opcodeTable["ud2"] = 399; - opcodeTable["verr"] = 400; - opcodeTable["verw"] = 401; - opcodeTable["wait"] = 402; - opcodeTable["wbinvd"] = 403; - opcodeTable["wrmsr"] = 404; - opcodeTable["xadd"] = 405; - opcodeTable["xchg"] = 406; - opcodeTable["xlat"] = 407; - opcodeTable["xlatb"] = 408; - opcodeTable["xor"] = 409; - opcodeTable["xrstor"] = 410; - opcodeTable["xrstor64"] = 411; - opcodeTable["xsave"] = 412; - opcodeTable["xsave64"] = 413; - opcodeTable["xsetbv"] = 414; - opcodeTable["addpd"] = 415; - opcodeTable["addps"] = 416; - opcodeTable["addsd"] = 417; - opcodeTable["addss"] = 418; - opcodeTable["addsubpd"] = 419; - opcodeTable["addsubps"] = 420; - opcodeTable["andnpd"] = 421; - opcodeTable["andnps"] = 422; - opcodeTable["andpd"] = 423; - opcodeTable["andps"] = 424; - opcodeTable["blendpd"] = 425; - opcodeTable["blendps"] = 426; - opcodeTable["cmppd"] = 427; - opcodeTable["cmpps"] = 428; - opcodeTable["comisd"] = 429; - opcodeTable["comiss"] = 430; - opcodeTable["cvtdq2pd"] = 431; - opcodeTable["cvtdq2ps"] = 432; - opcodeTable["cvtpd2dq"] = 433; - opcodeTable["cvtpd2pi"] = 434; - opcodeTable["cvtpd2ps"] = 435; - opcodeTable["cvtpi2pd"] = 436; - opcodeTable["cvtpi2ps"] = 437; - opcodeTable["cvtps2dq"] = 438; - opcodeTable["cvtps2pd"] = 439; - opcodeTable["cvtps2pi"] = 440; - opcodeTable["cvtsd2si"] = 441; - opcodeTable["cvtsd2ss"] = 442; - opcodeTable["cvtsi2sd"] = 443; - opcodeTable["cvtsi2ss"] = 444; - opcodeTable["cvtss2sd"] = 445; - opcodeTable["cvtss2si"] = 446; - opcodeTable["cvttpd2dq"] = 447; - opcodeTable["cvttpd2pi"] = 448; - opcodeTable["cvttps2dq"] = 449; - opcodeTable["cvttps2pi"] = 450; - opcodeTable["cvttsd2si"] = 451; - opcodeTable["cvttss2si"] = 452; - opcodeTable["divpd"] = 453; - opcodeTable["divps"] = 454; - opcodeTable["divsd"] = 455; - opcodeTable["divss"] = 456; - opcodeTable["dppd"] = 457; - opcodeTable["dpps"] = 458; - opcodeTable["hsubpd"] = 459; - opcodeTable["hsubps"] = 460; - opcodeTable["insertps"] = 461; - opcodeTable["lddqu"] = 462; - opcodeTable["maskmovdqu"] = 463; - opcodeTable["maskmovq"] = 464; - opcodeTable["maxpd"] = 465; - opcodeTable["maxps"] = 466; - opcodeTable["maxsd"] = 467; - opcodeTable["maxss"] = 468; - opcodeTable["mfence"] = 469; - opcodeTable["pause"] = 470; - opcodeTable["minpd"] = 471; - opcodeTable["minps"] = 472; - opcodeTable["minsd"] = 473; - opcodeTable["minss"] = 474; - opcodeTable["monitor"] = 475; - opcodeTable["movapd"] = 476; - opcodeTable["movaps"] = 477; - opcodeTable["movd"] = 478; - opcodeTable["movq"] = 479; - opcodeTable["movddup"] = 480; - opcodeTable["movdq2q"] = 481; - opcodeTable["movdqa"] = 482; - opcodeTable["movdqu"] = 483; - opcodeTable["movhlps"] = 484; - opcodeTable["movhpd"] = 485; - opcodeTable["movhps"] = 486; - opcodeTable["movlhps"] = 487; - opcodeTable["movlpd"] = 488; - opcodeTable["movlps"] = 489; - opcodeTable["movmskpd"] = 490; - opcodeTable["movmskps"] = 491; - opcodeTable["movntdq"] = 492; - opcodeTable["movnti"] = 493; - opcodeTable["movntpd"] = 494; - opcodeTable["movntd"] = 495; - opcodeTable["movntq"] = 496; - opcodeTable["movq2dq"] = 497; - opcodeTable["movshdup"] = 498; - opcodeTable["movsldup"] = 499; - opcodeTable["movss"] = 500; - opcodeTable["movupd"] = 501; - opcodeTable["movups"] = 502; - opcodeTable["mpsadbw"] = 503; - opcodeTable["mulpd"] = 504; - opcodeTable["mulps"] = 505; - opcodeTable["mulsd"] = 506; - opcodeTable["mulss"] = 507; - opcodeTable["orpd"] = 508; - opcodeTable["orps"] = 509; - opcodeTable["packssdw"] = 510; - opcodeTable["packsswb"] = 511; - opcodeTable["packusdw"] = 512; - opcodeTable["paddb"] = 513; - opcodeTable["paddd"] = 514; - opcodeTable["paddq"] = 515; - opcodeTable["paddsw"] = 516; - opcodeTable["paddusb"] = 517; - opcodeTable["paddusw"] = 518; - opcodeTable["paddw"] = 519; - opcodeTable["palignr"] = 520; - opcodeTable["pand"] = 521; - opcodeTable["pandn"] = 522; - opcodeTable["pavgb"] = 523; - opcodeTable["pavgw"] = 524; - opcodeTable["pblendw"] = 525; - opcodeTable["pcmpeqb"] = 526; - opcodeTable["pcmpeqd"] = 527; - opcodeTable["pcmpeqw"] = 528; - opcodeTable["pcmpestri"] = 529; - opcodeTable["pcmpestrm"] = 530; - opcodeTable["pcmpgtb"] = 531; - opcodeTable["pcmpgtd"] = 532; - opcodeTable["pcmpgtw"] = 533; - opcodeTable["pextrb"] = 534; - opcodeTable["pextrd"] = 535; - opcodeTable["pextrq"] = 536; - opcodeTable["pextrw"] = 537; - opcodeTable["pinsrb"] = 538; - opcodeTable["pinsrd"] = 539; - opcodeTable["pinsrq"] = 540; - opcodeTable["pinsrw"] = 541; - opcodeTable["pmaddwd"] = 542; - opcodeTable["pmaxsw"] = 543; - opcodeTable["pmaxub"] = 544; - opcodeTable["pminsw"] = 545; - opcodeTable["pminub"] = 546; - opcodeTable["pmovmskb"] = 547; - opcodeTable["pmulhuw"] = 548; - opcodeTable["pmulhw"] = 549; - opcodeTable["pmullw"] = 550; - opcodeTable["pmuludq"] = 551; - opcodeTable["psadbw"] = 552; - opcodeTable["pshufd"] = 553; - opcodeTable["pshufhw"] = 554; - opcodeTable["pshuflw"] = 555; - opcodeTable["pshufw"] = 556; - opcodeTable["pslld"] = 557; - opcodeTable["pslldq"] = 558; - opcodeTable["psllq"] = 559; - opcodeTable["psllw"] = 560; - opcodeTable["psrad"] = 561; - opcodeTable["psraw"] = 562; - opcodeTable["psrld"] = 563; - opcodeTable["psrldq"] = 564; - opcodeTable["psrlq"] = 565; - opcodeTable["psrlw"] = 566; - opcodeTable["psubb"] = 567; - opcodeTable["psubd"] = 568; - opcodeTable["psubq"] = 569; - opcodeTable["psubsb"] = 570; - opcodeTable["psubsw"] = 571; - opcodeTable["psubusb"] = 572; - opcodeTable["psubusw"] = 573; - opcodeTable["punpckhbw"] = 574; - opcodeTable["punpckhdq"] = 575; - opcodeTable["punpckhqdq"] = 576; - opcodeTable["punpckhwd"] = 577; - opcodeTable["punpcklbw"] = 578; - opcodeTable["punpckldq"] = 579; - opcodeTable["punpcklqdq"] = 580; - opcodeTable["punpcklwd"] = 581; - opcodeTable["pxor"] = 582; - opcodeTable["rcpps"] = 583; - opcodeTable["rcpss"] = 584; - opcodeTable["roundpd"] = 585; - opcodeTable["roundps"] = 586; - opcodeTable["roundsd"] = 587; - opcodeTable["roundss"] = 588; - opcodeTable["rsqrtps"] = 589; - opcodeTable["rsqrtss"] = 590; - opcodeTable["shufpd"] = 591; - opcodeTable["shufps"] = 592; - opcodeTable["sqrtpd"] = 593; - opcodeTable["sqrtps"] = 594; - opcodeTable["sqrtsd"] = 595; - opcodeTable["sqrtss"] = 596; - opcodeTable["subpd"] = 597; - opcodeTable["subps"] = 598; - opcodeTable["subsd"] = 599; - opcodeTable["subss"] = 600; - opcodeTable["ucomisd"] = 601; - opcodeTable["ucomiss"] = 602; - opcodeTable["unpckhpd"] = 603; - opcodeTable["unpckhps"] = 604; - opcodeTable["unpcklpd"] = 605; - opcodeTable["unpcklps"] = 606; - opcodeTable["xorpd"] = 607; - opcodeTable["xorps"] = 608; - opcodeTable["invept"] = 609; - opcodeTable["invvpid"] = 610; - opcodeTable["vmcall"] = 611; - opcodeTable["vmclear"] = 612; - opcodeTable["vmlaunch"] = 613; - opcodeTable["vmptrld"] = 614; - opcodeTable["vmptrst"] = 615; - opcodeTable["vmread"] = 616; - opcodeTable["vmresume"] = 617; - opcodeTable["vmwrite"] = 618; - opcodeTable["vmxoff"] = 619; - opcodeTable["vmxon"] = 620; + opcodeTable["clflush"] = 97; + opcodeTable["clflushopt"] = 98; + opcodeTable["cqo"] = 99; + opcodeTable["cwd"] = 100; + opcodeTable["cwde"] = 101; + opcodeTable["daa"] = 102; + opcodeTable["das"] = 103; + opcodeTable["dec"] = 104; + opcodeTable["div"] = 105; + opcodeTable["enter"] = 106; + opcodeTable["esc"] = 107; + opcodeTable["f2xm1"] = 108; + opcodeTable["fabs"] = 109; + opcodeTable["fadd"] = 110; + opcodeTable["faddp"] = 111; + opcodeTable["fbld"] = 112; + opcodeTable["fbstp"] = 113; + opcodeTable["fchs"] = 114; + opcodeTable["fclex"] = 115; + opcodeTable["fnclex"] = 116; + opcodeTable["fcmovb"] = 117; + opcodeTable["fcmovbe"] = 118; + opcodeTable["fcmove"] = 119; + opcodeTable["fcmovnb"] = 120; + opcodeTable["fcmovnbe"] = 121; + opcodeTable["fcmovne"] = 122; + opcodeTable["fcmovnu"] = 123; + opcodeTable["fcmovu"] = 124; + opcodeTable["fcom"] = 125; + opcodeTable["fcomi"] = 126; + opcodeTable["fcomip"] = 127; + opcodeTable["fcomp"] = 128; + opcodeTable["fcompp"] = 129; + opcodeTable["fcos"] = 130; + opcodeTable["fdecstp"] = 131; + opcodeTable["fdisi"] = 132; + opcodeTable["fdiv"] = 133; + opcodeTable["fdivp"] = 134; + opcodeTable["fdivr"] = 135; + opcodeTable["fdivrp"] = 136; + opcodeTable["feni"] = 137; + opcodeTable["ffree"] = 138; + opcodeTable["ffreep"] = 139; + opcodeTable["fiadd"] = 140; + opcodeTable["ficom"] = 141; + opcodeTable["ficomp"] = 142; + opcodeTable["fidiv"] = 143; + opcodeTable["fidivr"] = 144; + opcodeTable["fild"] = 145; + opcodeTable["fimul"] = 146; + opcodeTable["fincstp"] = 147; + opcodeTable["finit"] = 148; + opcodeTable["fninit"] = 149; + opcodeTable["fist"] = 150; + opcodeTable["fistp"] = 151; + opcodeTable["fisub"] = 152; + opcodeTable["fisubr"] = 153; + opcodeTable["fld"] = 154; + opcodeTable["fld1"] = 155; + opcodeTable["fldcw"] = 156; + opcodeTable["fldenv"] = 157; + opcodeTable["fldl2e"] = 158; + opcodeTable["fldl2t"] = 159; + opcodeTable["fldlg2"] = 160; + opcodeTable["fldln2"] = 161; + opcodeTable["fldpi"] = 162; + opcodeTable["fldz"] = 163; + opcodeTable["fmul"] = 164; + opcodeTable["fmulp"] = 165; + opcodeTable["fnop"] = 166; + opcodeTable["fnsave"] = 167; + opcodeTable["fpatan"] = 168; + opcodeTable["fprem"] = 169; + opcodeTable["fprem1"] = 170; + opcodeTable["fptan"] = 171; + opcodeTable["frndint"] = 172; + opcodeTable["frstor"] = 173; + opcodeTable["fsave"] = 174; + opcodeTable["fscale"] = 175; + opcodeTable["fsetpm"] = 176; + opcodeTable["fsin"] = 177; + opcodeTable["fsincos"] = 178; + opcodeTable["fsqrt"] = 179; + opcodeTable["fst"] = 180; + opcodeTable["fstcw"] = 181; + opcodeTable["fnstcw"] = 182; + opcodeTable["fstenv"] = 183; + opcodeTable["fnstenv"] = 184; + opcodeTable["fstp"] = 185; + opcodeTable["fstsw"] = 186; + opcodeTable["fnstsw"] = 187; + opcodeTable["fsub"] = 188; + opcodeTable["fsubp"] = 189; + opcodeTable["fsubr"] = 190; + opcodeTable["fsubrp"] = 191; + opcodeTable["ftst"] = 192; + opcodeTable["fucom"] = 193; + opcodeTable["fucomi"] = 194; + opcodeTable["fucomip"] = 195; + opcodeTable["fucomp"] = 196; + opcodeTable["fucompp"] = 197; + opcodeTable["fwait"] = 198; + opcodeTable["fxam"] = 199; + opcodeTable["fxch"] = 200; + opcodeTable["fxch4"] = 201; + opcodeTable["fxch7"] = 202; + opcodeTable["fxrstor"] = 203; + opcodeTable["fxsave"] = 204; + opcodeTable["fxtract"] = 205; + opcodeTable["fyl2x"] = 206; + opcodeTable["fyl2xp1"] = 207; + opcodeTable["hlt"] = 208; + opcodeTable["icebp"] = 209; + opcodeTable["idiv"] = 210; + opcodeTable["imul"] = 211; + opcodeTable["in"] = 212; + opcodeTable["ins"] = 213; + opcodeTable["insb"] = 214; + opcodeTable["insw"] = 215; + opcodeTable["insd"] = 216; + opcodeTable["inc"] = 217; + opcodeTable["int"] = 218; + opcodeTable["int1"] = 219; + opcodeTable["int3"] = 220; + opcodeTable["into"] = 221; + opcodeTable["invd"] = 222; + opcodeTable["invlpg"] = 223; + opcodeTable["iret"] = 224; + opcodeTable["iretw"] = 225; + opcodeTable["iretd"] = 226; + opcodeTable["iretq"] = 227; + opcodeTable["ja"] = 228; + opcodeTable["jae"] = 229; + opcodeTable["jb"] = 230; + opcodeTable["jbe"] = 231; + opcodeTable["jc"] = 232; + opcodeTable["jcxz"] = 233; + opcodeTable["jecxz"] = 234; + opcodeTable["je"] = 235; + opcodeTable["jg"] = 236; + opcodeTable["jge"] = 237; + opcodeTable["jl"] = 238; + opcodeTable["jle"] = 239; + opcodeTable["jmp"] = 240; + opcodeTable["jna"] = 241; + opcodeTable["jnae"] = 242; + opcodeTable["jnb"] = 243; + opcodeTable["jnbe"] = 244; + opcodeTable["jnc"] = 245; + opcodeTable["jne"] = 246; + opcodeTable["jng"] = 247; + opcodeTable["jnge"] = 248; + opcodeTable["jnl"] = 249; + opcodeTable["jnle"] = 250; + opcodeTable["jno"] = 251; + opcodeTable["jnp"] = 252; + opcodeTable["jns"] = 253; + opcodeTable["jnz"] = 254; + opcodeTable["jo"] = 255; + opcodeTable["jp"] = 256; + opcodeTable["jpe"] = 257; + opcodeTable["jpo"] = 258; + opcodeTable["js"] = 259; + opcodeTable["jz"] = 260; + opcodeTable["lahf"] = 261; + opcodeTable["lar"] = 262; + opcodeTable["lds"] = 263; + opcodeTable["lea"] = 264; + opcodeTable["leave"] = 265; + opcodeTable["les"] = 266; + opcodeTable["lfence"] = 267; + opcodeTable["lfs"] = 268; + opcodeTable["lgdt"] = 269; + opcodeTable["lgs"] = 270; + opcodeTable["lidt"] = 271; + opcodeTable["lldt"] = 272; + opcodeTable["lmsw"] = 273; + opcodeTable["lods"] = 274; + opcodeTable["lodsb"] = 275; + opcodeTable["lodsw"] = 276; + opcodeTable["lodsd"] = 277; + opcodeTable["lodsq"] = 278; + opcodeTable["loop"] = 279; + opcodeTable["loope"] = 280; + opcodeTable["loopne"] = 281; + opcodeTable["loopnz"] = 282; + opcodeTable["loopz"] = 283; + opcodeTable["lsl"] = 284; + opcodeTable["lss"] = 285; + opcodeTable["ltr"] = 286; + opcodeTable["mov"] = 287; + opcodeTable["movs"] = 288; + opcodeTable["movbe"] = 289; + opcodeTable["movsb"] = 290; + opcodeTable["movsw"] = 291; + opcodeTable["movsd"] = 292; + opcodeTable["movsq"] = 293; + opcodeTable["movsx"] = 294; + opcodeTable["movzx"] = 295; + opcodeTable["movsxd"] = 296; + opcodeTable["mul"] = 297; + opcodeTable["neg"] = 298; + opcodeTable["nop"] = 299; + opcodeTable["not"] = 300; + opcodeTable["or"] = 301; + opcodeTable["out"] = 302; + opcodeTable["outs"] = 303; + opcodeTable["outsb"] = 304; + opcodeTable["outsw"] = 305; + opcodeTable["outsd"] = 306; + opcodeTable["pop"] = 307; + opcodeTable["popa"] = 308; + opcodeTable["popaw"] = 309; + opcodeTable["popad"] = 310; + opcodeTable["popcnt"] = 311; + opcodeTable["popf"] = 312; + opcodeTable["popfw"] = 313; + opcodeTable["popfd"] = 314; + opcodeTable["popfq"] = 315; + opcodeTable["prefetchnta"] = 316; + opcodeTable["prefetcht0"] = 317; + opcodeTable["prefetcht1"] = 318; + opcodeTable["prefetcht2"] = 319; + opcodeTable["push"] = 320; + opcodeTable["pusha"] = 321; + opcodeTable["pushaw"] = 322; + opcodeTable["pushad"] = 323; + opcodeTable["pushf"] = 324; + opcodeTable["pushfw"] = 325; + opcodeTable["pushfd"] = 326; + opcodeTable["pushfq"] = 327; + opcodeTable["rcl"] = 328; + opcodeTable["rcr"] = 329; + opcodeTable["rdmsr"] = 330; + opcodeTable["rdpmc"] = 331; + opcodeTable["rdtsc"] = 332; + opcodeTable["ret"] = 333; + opcodeTable["retf"] = 334; + opcodeTable["rol"] = 335; + opcodeTable["ror"] = 336; + opcodeTable["rsm"] = 337; + opcodeTable["sahf"] = 338; + opcodeTable["sal"] = 339; + opcodeTable["sar"] = 340; + opcodeTable["sbb"] = 341; + opcodeTable["scas"] = 342; + opcodeTable["scasb"] = 343; + opcodeTable["scasw"] = 344; + opcodeTable["scasd"] = 345; + opcodeTable["scasq"] = 346; + opcodeTable["seta"] = 347; + opcodeTable["setae"] = 348; + opcodeTable["setb"] = 349; + opcodeTable["setbe"] = 350; + opcodeTable["setc"] = 351; + opcodeTable["sete"] = 352; + opcodeTable["setg"] = 353; + opcodeTable["setge"] = 354; + opcodeTable["setl"] = 355; + opcodeTable["setle"] = 356; + opcodeTable["setna"] = 357; + opcodeTable["setnae"] = 358; + opcodeTable["setnb"] = 359; + opcodeTable["setnbe"] = 360; + opcodeTable["setnc"] = 361; + opcodeTable["setne"] = 362; + opcodeTable["setng"] = 363; + opcodeTable["setnge"] = 364; + opcodeTable["setnl"] = 365; + opcodeTable["setnle"] = 366; + opcodeTable["setno"] = 367; + opcodeTable["setnp"] = 368; + opcodeTable["setns"] = 369; + opcodeTable["setnz"] = 370; + opcodeTable["seto"] = 371; + opcodeTable["setp"] = 372; + opcodeTable["setpe"] = 373; + opcodeTable["setpo"] = 374; + opcodeTable["sets"] = 375; + opcodeTable["setz"] = 376; + opcodeTable["sfence"] = 377; + opcodeTable["sgdt"] = 378; + opcodeTable["shl"] = 379; + opcodeTable["shld"] = 380; + opcodeTable["shr"] = 381; + opcodeTable["shrd"] = 382; + opcodeTable["sidt"] = 383; + opcodeTable["sldt"] = 384; + opcodeTable["smsw"] = 385; + opcodeTable["stc"] = 386; + opcodeTable["std"] = 387; + opcodeTable["sti"] = 388; + opcodeTable["stos"] = 389; + opcodeTable["stosb"] = 390; + opcodeTable["stosw"] = 391; + opcodeTable["stosd"] = 392; + opcodeTable["stosq"] = 393; + opcodeTable["str"] = 394; + opcodeTable["sub"] = 395; + opcodeTable["syscall"] = 396; + opcodeTable["sysenter"] = 397; + opcodeTable["sysexit"] = 398; + opcodeTable["sysret"] = 399; + opcodeTable["test"] = 400; + opcodeTable["ud2"] = 401; + opcodeTable["verr"] = 402; + opcodeTable["verw"] = 403; + opcodeTable["wait"] = 404; + opcodeTable["wbinvd"] = 405; + opcodeTable["wrmsr"] = 406; + opcodeTable["xadd"] = 407; + opcodeTable["xchg"] = 408; + opcodeTable["xlat"] = 409; + opcodeTable["xlatb"] = 410; + opcodeTable["xor"] = 411; + opcodeTable["xrstor"] = 412; + opcodeTable["xrstor64"] = 413; + opcodeTable["xsave"] = 414; + opcodeTable["xsave64"] = 415; + opcodeTable["xsetbv"] = 416; + opcodeTable["addpd"] = 417; + opcodeTable["addps"] = 418; + opcodeTable["addsd"] = 419; + opcodeTable["addss"] = 420; + opcodeTable["addsubpd"] = 421; + opcodeTable["addsubps"] = 422; + opcodeTable["andnpd"] = 423; + opcodeTable["andnps"] = 424; + opcodeTable["andpd"] = 425; + opcodeTable["andps"] = 426; + opcodeTable["blendpd"] = 427; + opcodeTable["blendps"] = 428; + opcodeTable["cmppd"] = 429; + opcodeTable["cmpps"] = 430; + opcodeTable["comisd"] = 431; + opcodeTable["comiss"] = 432; + opcodeTable["cvtdq2pd"] = 433; + opcodeTable["cvtdq2ps"] = 434; + opcodeTable["cvtpd2dq"] = 435; + opcodeTable["cvtpd2pi"] = 436; + opcodeTable["cvtpd2ps"] = 437; + opcodeTable["cvtpi2pd"] = 438; + opcodeTable["cvtpi2ps"] = 439; + opcodeTable["cvtps2dq"] = 440; + opcodeTable["cvtps2pd"] = 441; + opcodeTable["cvtps2pi"] = 442; + opcodeTable["cvtsd2si"] = 443; + opcodeTable["cvtsd2ss"] = 444; + opcodeTable["cvtsi2sd"] = 445; + opcodeTable["cvtsi2ss"] = 446; + opcodeTable["cvtss2sd"] = 447; + opcodeTable["cvtss2si"] = 448; + opcodeTable["cvttpd2dq"] = 449; + opcodeTable["cvttpd2pi"] = 450; + opcodeTable["cvttps2dq"] = 451; + opcodeTable["cvttps2pi"] = 452; + opcodeTable["cvttsd2si"] = 453; + opcodeTable["cvttss2si"] = 454; + opcodeTable["divpd"] = 455; + opcodeTable["divps"] = 456; + opcodeTable["divsd"] = 457; + opcodeTable["divss"] = 458; + opcodeTable["dppd"] = 459; + opcodeTable["dpps"] = 460; + opcodeTable["hsubpd"] = 461; + opcodeTable["hsubps"] = 462; + opcodeTable["insertps"] = 463; + opcodeTable["lddqu"] = 464; + opcodeTable["maskmovdqu"] = 465; + opcodeTable["maskmovq"] = 466; + opcodeTable["maxpd"] = 467; + opcodeTable["maxps"] = 468; + opcodeTable["maxsd"] = 469; + opcodeTable["maxss"] = 470; + opcodeTable["mfence"] = 471; + opcodeTable["pause"] = 472; + opcodeTable["minpd"] = 473; + opcodeTable["minps"] = 474; + opcodeTable["minsd"] = 475; + opcodeTable["minss"] = 476; + opcodeTable["monitor"] = 477; + opcodeTable["movapd"] = 478; + opcodeTable["movaps"] = 479; + opcodeTable["movd"] = 480; + opcodeTable["movq"] = 481; + opcodeTable["movddup"] = 482; + opcodeTable["movdq2q"] = 483; + opcodeTable["movdqa"] = 484; + opcodeTable["movdqu"] = 485; + opcodeTable["movhlps"] = 486; + opcodeTable["movhpd"] = 487; + opcodeTable["movhps"] = 488; + opcodeTable["movlhps"] = 489; + opcodeTable["movlpd"] = 490; + opcodeTable["movlps"] = 491; + opcodeTable["movmskpd"] = 492; + opcodeTable["movmskps"] = 493; + opcodeTable["movntdq"] = 494; + opcodeTable["movnti"] = 495; + opcodeTable["movntpd"] = 496; + opcodeTable["movntd"] = 497; + opcodeTable["movntq"] = 498; + opcodeTable["movq2dq"] = 499; + opcodeTable["movshdup"] = 500; + opcodeTable["movsldup"] = 501; + opcodeTable["movss"] = 502; + opcodeTable["movupd"] = 503; + opcodeTable["movups"] = 504; + opcodeTable["mpsadbw"] = 505; + opcodeTable["mulpd"] = 506; + opcodeTable["mulps"] = 507; + opcodeTable["mulsd"] = 508; + opcodeTable["mulss"] = 509; + opcodeTable["orpd"] = 510; + opcodeTable["orps"] = 511; + opcodeTable["packssdw"] = 512; + opcodeTable["packsswb"] = 513; + opcodeTable["packusdw"] = 514; + opcodeTable["paddb"] = 515; + opcodeTable["paddd"] = 516; + opcodeTable["paddq"] = 517; + opcodeTable["paddsw"] = 518; + opcodeTable["paddusb"] = 519; + opcodeTable["paddusw"] = 520; + opcodeTable["paddw"] = 521; + opcodeTable["palignr"] = 522; + opcodeTable["pand"] = 523; + opcodeTable["pandn"] = 524; + opcodeTable["pavgb"] = 525; + opcodeTable["pavgw"] = 526; + opcodeTable["pblendw"] = 527; + opcodeTable["pcmpeqb"] = 528; + opcodeTable["pcmpeqd"] = 529; + opcodeTable["pcmpeqw"] = 530; + opcodeTable["pcmpestri"] = 531; + opcodeTable["pcmpestrm"] = 532; + opcodeTable["pcmpgtb"] = 533; + opcodeTable["pcmpgtd"] = 534; + opcodeTable["pcmpgtw"] = 535; + opcodeTable["pextrb"] = 536; + opcodeTable["pextrd"] = 537; + opcodeTable["pextrq"] = 538; + opcodeTable["pextrw"] = 539; + opcodeTable["pinsrb"] = 540; + opcodeTable["pinsrd"] = 541; + opcodeTable["pinsrq"] = 542; + opcodeTable["pinsrw"] = 543; + opcodeTable["pmaddwd"] = 544; + opcodeTable["pmaxsw"] = 545; + opcodeTable["pmaxub"] = 546; + opcodeTable["pminsw"] = 547; + opcodeTable["pminub"] = 548; + opcodeTable["pmovmskb"] = 549; + opcodeTable["pmulhuw"] = 550; + opcodeTable["pmulhw"] = 551; + opcodeTable["pmullw"] = 552; + opcodeTable["pmuludq"] = 553; + opcodeTable["psadbw"] = 554; + opcodeTable["pshufd"] = 555; + opcodeTable["pshufhw"] = 556; + opcodeTable["pshuflw"] = 557; + opcodeTable["pshufw"] = 558; + opcodeTable["pslld"] = 559; + opcodeTable["pslldq"] = 560; + opcodeTable["psllq"] = 561; + opcodeTable["psllw"] = 562; + opcodeTable["psrad"] = 563; + opcodeTable["psraw"] = 564; + opcodeTable["psrld"] = 565; + opcodeTable["psrldq"] = 566; + opcodeTable["psrlq"] = 567; + opcodeTable["psrlw"] = 568; + opcodeTable["psubb"] = 569; + opcodeTable["psubd"] = 570; + opcodeTable["psubq"] = 571; + opcodeTable["psubsb"] = 572; + opcodeTable["psubsw"] = 573; + opcodeTable["psubusb"] = 574; + opcodeTable["psubusw"] = 575; + opcodeTable["punpckhbw"] = 576; + opcodeTable["punpckhdq"] = 577; + opcodeTable["punpckhqdq"] = 578; + opcodeTable["punpckhwd"] = 579; + opcodeTable["punpcklbw"] = 580; + opcodeTable["punpckldq"] = 581; + opcodeTable["punpcklqdq"] = 582; + opcodeTable["punpcklwd"] = 583; + opcodeTable["pxor"] = 584; + opcodeTable["rcpps"] = 585; + opcodeTable["rcpss"] = 586; + opcodeTable["roundpd"] = 587; + opcodeTable["roundps"] = 588; + opcodeTable["roundsd"] = 589; + opcodeTable["roundss"] = 590; + opcodeTable["rsqrtps"] = 591; + opcodeTable["rsqrtss"] = 592; + opcodeTable["shufpd"] = 593; + opcodeTable["shufps"] = 594; + opcodeTable["sqrtpd"] = 595; + opcodeTable["sqrtps"] = 596; + opcodeTable["sqrtsd"] = 597; + opcodeTable["sqrtss"] = 598; + opcodeTable["subpd"] = 599; + opcodeTable["subps"] = 600; + opcodeTable["subsd"] = 601; + opcodeTable["subss"] = 602; + opcodeTable["ucomisd"] = 603; + opcodeTable["ucomiss"] = 604; + opcodeTable["unpckhpd"] = 605; + opcodeTable["unpckhps"] = 606; + opcodeTable["unpcklpd"] = 607; + opcodeTable["unpcklps"] = 608; + opcodeTable["xorpd"] = 609; + opcodeTable["xorps"] = 610; + opcodeTable["invept"] = 611; + opcodeTable["invvpid"] = 612; + opcodeTable["vmcall"] = 613; + opcodeTable["vmclear"] = 614; + opcodeTable["vmlaunch"] = 615; + opcodeTable["vmptrld"] = 616; + opcodeTable["vmptrst"] = 617; + opcodeTable["vmread"] = 618; + opcodeTable["vmresume"] = 619; + opcodeTable["vmwrite"] = 620; + opcodeTable["vmxoff"] = 621; + opcodeTable["vmxon"] = 622; prefixTable["a16"] = 0; prefixTable["a32"] = 1; prefixTable["lock"] = 2; @@ -24112,17 +24114,84 @@ x64Token x64Parser::tokenBranches6242[] = { {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6243, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6246(x64Operand &operand, int tokenPos) +Coding x64Parser::tokenCoding6247_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6247_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6247(x64Operand &operand, int tokenPos) { operand.operandCoding = 501; + operand.values[16] = tokenCoding6247_16; + operand.values[17] = tokenCoding6247_17; + operand.values[18] = tokenCoding6247_18; + operand.values[19] = tokenCoding6247_19; } +x64Token x64Parser::tokenBranches6246[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc6247, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches6245[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6246, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6246 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) +Coding x64Parser::tokenCoding6250_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6250_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6250(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 501; + operand.values[16] = tokenCoding6250_16; + operand.values[17] = tokenCoding6250_17; + operand.values[18] = tokenCoding6250_18; + operand.values[19] = tokenCoding6250_19; +} +x64Token x64Parser::tokenBranches6249[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc6250, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6248[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6249 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6252(x64Operand &operand, int tokenPos) { operand.operandCoding = 502; +} +x64Token x64Parser::tokenBranches6251[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6252, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6264(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 503; operand.values[27] = new Coding[2]; CleanupValues.push_back(operand.values[27]); operand.values[27]->type = Coding::number; @@ -24134,19 +24203,19 @@ void x64Parser::TokenFunc6258(x64Operand &operand, int tokenPos) operand.values[27][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6257[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6258, }, +x64Token x64Parser::tokenBranches6263[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6264, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6256[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6257 }, +x64Token x64Parser::tokenBranches6262[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6263 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6255[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6256 }, +x64Token x64Parser::tokenBranches6261[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6262 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6261(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -24159,49 +24228,49 @@ void x64Parser::TokenFunc6255(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6254[] = { - {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6255, x64Parser::tokenBranches6255 }, +x64Token x64Parser::tokenBranches6260[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6261, x64Parser::tokenBranches6261 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6253[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6254 }, +x64Token x64Parser::tokenBranches6259[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6260 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6262_16[] = { +Coding x64Parser::tokenCoding6268_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_17[] = { +Coding x64Parser::tokenCoding6268_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_18[] = { +Coding x64Parser::tokenCoding6268_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '&' }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6262_19[] = { +Coding x64Parser::tokenCoding6268_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 27, 5, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 22, 0, 0, 0, '>' }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6262(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6268(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6262_16; - operand.values[17] = tokenCoding6262_17; - operand.values[18] = tokenCoding6262_18; - operand.values[19] = tokenCoding6262_19; + operand.values[16] = tokenCoding6268_16; + operand.values[17] = tokenCoding6268_17; + operand.values[18] = tokenCoding6268_18; + operand.values[19] = tokenCoding6268_19; } -x64Token x64Parser::tokenBranches6261[] = { - {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6262, }, +x64Token x64Parser::tokenBranches6267[] = { + {x64Token::ADDRESSCLASS, 0, 1, 0, NULL,&x64Parser::TokenFunc6268, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6260[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6261 }, +x64Token x64Parser::tokenBranches6266[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6267 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6266(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -24214,11 +24283,11 @@ void x64Parser::TokenFunc6260(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6259[] = { - {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6260, x64Parser::tokenBranches6260 }, +x64Token x64Parser::tokenBranches6265[] = { + {x64Token::NUMBER, 2, 0, 0, NULL,&x64Parser::TokenFunc6266, x64Parser::tokenBranches6266 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6281(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24231,19 +24300,19 @@ void x64Parser::TokenFunc6275(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6274[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6275, }, +x64Token x64Parser::tokenBranches6280[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6281, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6273[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6274 }, +x64Token x64Parser::tokenBranches6279[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6272[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6273 }, +x64Token x64Parser::tokenBranches6278[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6279 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6285(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24256,19 +24325,19 @@ void x64Parser::TokenFunc6279(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6278[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6279, }, +x64Token x64Parser::tokenBranches6284[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6285, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6277[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6278 }, +x64Token x64Parser::tokenBranches6283[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6276[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6277 }, +x64Token x64Parser::tokenBranches6282[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6283 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6289(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24281,19 +24350,19 @@ void x64Parser::TokenFunc6283(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6282[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6283, }, +x64Token x64Parser::tokenBranches6288[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6289, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6281[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6282 }, +x64Token x64Parser::tokenBranches6287[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6288 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6280[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6281 }, +x64Token x64Parser::tokenBranches6286[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6287 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6293(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24306,19 +24375,19 @@ void x64Parser::TokenFunc6287(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6286[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6287, }, +x64Token x64Parser::tokenBranches6292[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6293, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6285[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6286 }, +x64Token x64Parser::tokenBranches6291[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6292 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6284[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6285 }, +x64Token x64Parser::tokenBranches6290[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6291 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6297(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24331,19 +24400,19 @@ void x64Parser::TokenFunc6291(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6290[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6291, }, +x64Token x64Parser::tokenBranches6296[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6297, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6289[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6290 }, +x64Token x64Parser::tokenBranches6295[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6296 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6288[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6289 }, +x64Token x64Parser::tokenBranches6294[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6295 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6301(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24356,19 +24425,19 @@ void x64Parser::TokenFunc6295(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6294[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6295, }, +x64Token x64Parser::tokenBranches6300[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6301, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6293[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6294 }, +x64Token x64Parser::tokenBranches6299[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6300 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6292[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6293 }, +x64Token x64Parser::tokenBranches6298[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6299 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6305(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24381,19 +24450,19 @@ void x64Parser::TokenFunc6299(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6298[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6299, }, +x64Token x64Parser::tokenBranches6304[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6305, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6297[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6298 }, +x64Token x64Parser::tokenBranches6303[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6304 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6296[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6297 }, +x64Token x64Parser::tokenBranches6302[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6303 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6309(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24406,19 +24475,19 @@ void x64Parser::TokenFunc6303(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6302[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6303, }, +x64Token x64Parser::tokenBranches6308[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6309, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6301[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6302 }, +x64Token x64Parser::tokenBranches6307[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6308 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6300[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6301 }, +x64Token x64Parser::tokenBranches6306[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6307 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6313(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24431,60 +24500,60 @@ void x64Parser::TokenFunc6307(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6306[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6307, }, +x64Token x64Parser::tokenBranches6312[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6313, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6305[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6306 }, +x64Token x64Parser::tokenBranches6311[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6312 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6310_16[] = { +Coding x64Parser::tokenCoding6316_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6310_17[] = { +Coding x64Parser::tokenCoding6316_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6310_19[] = { +Coding x64Parser::tokenCoding6316_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6310(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6310_16; - operand.values[17] = tokenCoding6310_17; - operand.values[19] = tokenCoding6310_19; + operand.values[16] = tokenCoding6316_16; + operand.values[17] = tokenCoding6316_17; + operand.values[19] = tokenCoding6316_19; } -x64Token x64Parser::tokenBranches6309[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6310, }, +x64Token x64Parser::tokenBranches6315[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6316, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6312_16[] = { +Coding x64Parser::tokenCoding6318_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6312_17[] = { +Coding x64Parser::tokenCoding6318_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6312_19[] = { +Coding x64Parser::tokenCoding6318_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6312(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6318(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6312_16; - operand.values[17] = tokenCoding6312_17; - operand.values[19] = tokenCoding6312_19; + operand.values[16] = tokenCoding6318_16; + operand.values[17] = tokenCoding6318_17; + operand.values[19] = tokenCoding6318_19; } -x64Token x64Parser::tokenBranches6311[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6312, }, +x64Token x64Parser::tokenBranches6317[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6318, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6314(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24497,14 +24566,14 @@ void x64Parser::TokenFunc6308(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6304[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6305 }, - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6308, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6309 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, +x64Token x64Parser::tokenBranches6310[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6311 }, + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6314, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6317 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24517,19 +24586,19 @@ void x64Parser::TokenFunc6316(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6315[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6316, }, +x64Token x64Parser::tokenBranches6321[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6314[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6315 }, +x64Token x64Parser::tokenBranches6320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6321 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6313[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6314 }, +x64Token x64Parser::tokenBranches6319[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6320 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24542,64 +24611,64 @@ void x64Parser::TokenFunc6320(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6319[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6320, }, +x64Token x64Parser::tokenBranches6325[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6326, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6318[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6319 }, +x64Token x64Parser::tokenBranches6324[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6317[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6318 }, +x64Token x64Parser::tokenBranches6323[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6324 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6324_16[] = { +Coding x64Parser::tokenCoding6330_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6324_17[] = { +Coding x64Parser::tokenCoding6330_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6324_19[] = { +Coding x64Parser::tokenCoding6330_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6324(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6330(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6324_16; - operand.values[17] = tokenCoding6324_17; - operand.values[19] = tokenCoding6324_19; + operand.values[16] = tokenCoding6330_16; + operand.values[17] = tokenCoding6330_17; + operand.values[19] = tokenCoding6330_19; } -x64Token x64Parser::tokenBranches6323[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6324, }, +x64Token x64Parser::tokenBranches6329[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6330, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6326_16[] = { +Coding x64Parser::tokenCoding6332_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6326_17[] = { +Coding x64Parser::tokenCoding6332_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6326_19[] = { +Coding x64Parser::tokenCoding6332_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6326(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6332(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6326_16; - operand.values[17] = tokenCoding6326_17; - operand.values[19] = tokenCoding6326_19; + operand.values[16] = tokenCoding6332_16; + operand.values[17] = tokenCoding6332_17; + operand.values[19] = tokenCoding6332_19; } -x64Token x64Parser::tokenBranches6325[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6326, }, +x64Token x64Parser::tokenBranches6331[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6332, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6328(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -24612,622 +24681,567 @@ void x64Parser::TokenFunc6322(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6321[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6322, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6323 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6325 }, +x64Token x64Parser::tokenBranches6327[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6328, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6329 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6331 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6337_18[] = { +Coding x64Parser::tokenCoding6343_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6337_19[] = { +Coding x64Parser::tokenCoding6343_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6337(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6343(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6337_18; - operand.values[19] = tokenCoding6337_19; + operand.values[18] = tokenCoding6343_18; + operand.values[19] = tokenCoding6343_19; } -x64Token x64Parser::tokenBranches6336[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6337, }, +x64Token x64Parser::tokenBranches6342[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6343, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6339_18[] = { +Coding x64Parser::tokenCoding6345_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6339_19[] = { +Coding x64Parser::tokenCoding6345_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 223, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6339(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6345(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6339_18; - operand.values[19] = tokenCoding6339_19; + operand.values[18] = tokenCoding6345_18; + operand.values[19] = tokenCoding6345_19; } -x64Token x64Parser::tokenBranches6338[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6339, }, +x64Token x64Parser::tokenBranches6344[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6345, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6347_16[] = { +Coding x64Parser::tokenCoding6353_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_17[] = { +Coding x64Parser::tokenCoding6353_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_18[] = { +Coding x64Parser::tokenCoding6353_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6347_19[] = { +Coding x64Parser::tokenCoding6353_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6347(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6353(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6347_16; - operand.values[17] = tokenCoding6347_17; - operand.values[18] = tokenCoding6347_18; - operand.values[19] = tokenCoding6347_19; + operand.values[16] = tokenCoding6353_16; + operand.values[17] = tokenCoding6353_17; + operand.values[18] = tokenCoding6353_18; + operand.values[19] = tokenCoding6353_19; } -x64Token x64Parser::tokenBranches6346[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6347, }, +x64Token x64Parser::tokenBranches6352[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6353, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6349_16[] = { +Coding x64Parser::tokenCoding6355_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_17[] = { +Coding x64Parser::tokenCoding6355_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_18[] = { +Coding x64Parser::tokenCoding6355_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6349_19[] = { +Coding x64Parser::tokenCoding6355_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6349(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6355(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6349_16; - operand.values[17] = tokenCoding6349_17; - operand.values[18] = tokenCoding6349_18; - operand.values[19] = tokenCoding6349_19; + operand.values[16] = tokenCoding6355_16; + operand.values[17] = tokenCoding6355_17; + operand.values[18] = tokenCoding6355_18; + operand.values[19] = tokenCoding6355_19; } -x64Token x64Parser::tokenBranches6348[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6349, }, +x64Token x64Parser::tokenBranches6354[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6355, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6351_16[] = { +Coding x64Parser::tokenCoding6357_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_17[] = { +Coding x64Parser::tokenCoding6357_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_18[] = { +Coding x64Parser::tokenCoding6357_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6351_19[] = { +Coding x64Parser::tokenCoding6357_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6351(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6357(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6351_16; - operand.values[17] = tokenCoding6351_17; - operand.values[18] = tokenCoding6351_18; - operand.values[19] = tokenCoding6351_19; + operand.values[16] = tokenCoding6357_16; + operand.values[17] = tokenCoding6357_17; + operand.values[18] = tokenCoding6357_18; + operand.values[19] = tokenCoding6357_19; } -x64Token x64Parser::tokenBranches6350[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6351, }, +x64Token x64Parser::tokenBranches6356[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6357, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6345[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6346 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6348 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6350 }, +x64Token x64Parser::tokenBranches6351[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6352 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6354 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6356 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6359_16[] = { +Coding x64Parser::tokenCoding6365_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_17[] = { +Coding x64Parser::tokenCoding6365_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_18[] = { +Coding x64Parser::tokenCoding6365_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6359_19[] = { +Coding x64Parser::tokenCoding6365_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6359(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6359_16; - operand.values[17] = tokenCoding6359_17; - operand.values[18] = tokenCoding6359_18; - operand.values[19] = tokenCoding6359_19; + operand.values[16] = tokenCoding6365_16; + operand.values[17] = tokenCoding6365_17; + operand.values[18] = tokenCoding6365_18; + operand.values[19] = tokenCoding6365_19; } -x64Token x64Parser::tokenBranches6358[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6359, }, +x64Token x64Parser::tokenBranches6364[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6365, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6361_16[] = { +Coding x64Parser::tokenCoding6367_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_17[] = { +Coding x64Parser::tokenCoding6367_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_18[] = { +Coding x64Parser::tokenCoding6367_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6361_19[] = { +Coding x64Parser::tokenCoding6367_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6361(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6361_16; - operand.values[17] = tokenCoding6361_17; - operand.values[18] = tokenCoding6361_18; - operand.values[19] = tokenCoding6361_19; + operand.values[16] = tokenCoding6367_16; + operand.values[17] = tokenCoding6367_17; + operand.values[18] = tokenCoding6367_18; + operand.values[19] = tokenCoding6367_19; } -x64Token x64Parser::tokenBranches6360[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6361, }, +x64Token x64Parser::tokenBranches6366[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6357[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6358 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6360 }, +x64Token x64Parser::tokenBranches6363[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6364 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6367_16[] = { +Coding x64Parser::tokenCoding6373_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_17[] = { +Coding x64Parser::tokenCoding6373_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_18[] = { +Coding x64Parser::tokenCoding6373_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6367_19[] = { +Coding x64Parser::tokenCoding6373_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6367(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6373(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6367_16; - operand.values[17] = tokenCoding6367_17; - operand.values[18] = tokenCoding6367_18; - operand.values[19] = tokenCoding6367_19; + operand.values[16] = tokenCoding6373_16; + operand.values[17] = tokenCoding6373_17; + operand.values[18] = tokenCoding6373_18; + operand.values[19] = tokenCoding6373_19; } -x64Token x64Parser::tokenBranches6366[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6367, }, +x64Token x64Parser::tokenBranches6372[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6373, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6369_16[] = { +Coding x64Parser::tokenCoding6375_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_17[] = { +Coding x64Parser::tokenCoding6375_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_18[] = { +Coding x64Parser::tokenCoding6375_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6369_19[] = { +Coding x64Parser::tokenCoding6375_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6369(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6369_16; - operand.values[17] = tokenCoding6369_17; - operand.values[18] = tokenCoding6369_18; - operand.values[19] = tokenCoding6369_19; + operand.values[16] = tokenCoding6375_16; + operand.values[17] = tokenCoding6375_17; + operand.values[18] = tokenCoding6375_18; + operand.values[19] = tokenCoding6375_19; } -x64Token x64Parser::tokenBranches6368[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6369, }, +x64Token x64Parser::tokenBranches6374[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6371_16[] = { +Coding x64Parser::tokenCoding6377_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_17[] = { +Coding x64Parser::tokenCoding6377_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_18[] = { +Coding x64Parser::tokenCoding6377_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6371_19[] = { +Coding x64Parser::tokenCoding6377_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6371_16; - operand.values[17] = tokenCoding6371_17; - operand.values[18] = tokenCoding6371_18; - operand.values[19] = tokenCoding6371_19; + operand.values[16] = tokenCoding6377_16; + operand.values[17] = tokenCoding6377_17; + operand.values[18] = tokenCoding6377_18; + operand.values[19] = tokenCoding6377_19; } -x64Token x64Parser::tokenBranches6370[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6371, }, +x64Token x64Parser::tokenBranches6376[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6365_18[] = { +Coding x64Parser::tokenCoding6371_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6365_19[] = { +Coding x64Parser::tokenCoding6371_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6365(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6371(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6365_18; - operand.values[19] = tokenCoding6365_19; + operand.values[18] = tokenCoding6371_18; + operand.values[19] = tokenCoding6371_19; } -x64Token x64Parser::tokenBranches6364[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6365, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6366 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6368 }, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6370 }, +x64Token x64Parser::tokenBranches6370[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6371, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6372 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6374 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6376 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6375_16[] = { +Coding x64Parser::tokenCoding6381_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_17[] = { +Coding x64Parser::tokenCoding6381_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_18[] = { +Coding x64Parser::tokenCoding6381_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6375_19[] = { +Coding x64Parser::tokenCoding6381_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6375(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6381(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6375_16; - operand.values[17] = tokenCoding6375_17; - operand.values[18] = tokenCoding6375_18; - operand.values[19] = tokenCoding6375_19; + operand.values[16] = tokenCoding6381_16; + operand.values[17] = tokenCoding6381_17; + operand.values[18] = tokenCoding6381_18; + operand.values[19] = tokenCoding6381_19; } -x64Token x64Parser::tokenBranches6374[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6375, }, +x64Token x64Parser::tokenBranches6380[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6381, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6373[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6374 }, +x64Token x64Parser::tokenBranches6379[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6380 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6377_16[] = { +Coding x64Parser::tokenCoding6383_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_17[] = { +Coding x64Parser::tokenCoding6383_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_18[] = { +Coding x64Parser::tokenCoding6383_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6377_19[] = { +Coding x64Parser::tokenCoding6383_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6377(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6383(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6377_16; - operand.values[17] = tokenCoding6377_17; - operand.values[18] = tokenCoding6377_18; - operand.values[19] = tokenCoding6377_19; + operand.values[16] = tokenCoding6383_16; + operand.values[17] = tokenCoding6383_17; + operand.values[18] = tokenCoding6383_18; + operand.values[19] = tokenCoding6383_19; } -x64Token x64Parser::tokenBranches6376[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6377, }, +x64Token x64Parser::tokenBranches6382[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6383, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6388_16[] = { +Coding x64Parser::tokenCoding6394_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_17[] = { +Coding x64Parser::tokenCoding6394_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_18[] = { +Coding x64Parser::tokenCoding6394_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6388_19[] = { +Coding x64Parser::tokenCoding6394_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6388(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6394(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6388_16; - operand.values[17] = tokenCoding6388_17; - operand.values[18] = tokenCoding6388_18; - operand.values[19] = tokenCoding6388_19; + operand.values[16] = tokenCoding6394_16; + operand.values[17] = tokenCoding6394_17; + operand.values[18] = tokenCoding6394_18; + operand.values[19] = tokenCoding6394_19; } -x64Token x64Parser::tokenBranches6387[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6388, }, +x64Token x64Parser::tokenBranches6393[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6394, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6395_16[] = { +Coding x64Parser::tokenCoding6401_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_17[] = { +Coding x64Parser::tokenCoding6401_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_18[] = { +Coding x64Parser::tokenCoding6401_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6395_19[] = { +Coding x64Parser::tokenCoding6401_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6395(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6401(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6395_16; - operand.values[17] = tokenCoding6395_17; - operand.values[18] = tokenCoding6395_18; - operand.values[19] = tokenCoding6395_19; + operand.values[16] = tokenCoding6401_16; + operand.values[17] = tokenCoding6401_17; + operand.values[18] = tokenCoding6401_18; + operand.values[19] = tokenCoding6401_19; } -x64Token x64Parser::tokenBranches6394[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6395, }, +x64Token x64Parser::tokenBranches6400[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6401, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6397_16[] = { +Coding x64Parser::tokenCoding6403_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_17[] = { +Coding x64Parser::tokenCoding6403_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_18[] = { +Coding x64Parser::tokenCoding6403_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6397_19[] = { +Coding x64Parser::tokenCoding6403_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6397(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6403(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6397_16; - operand.values[17] = tokenCoding6397_17; - operand.values[18] = tokenCoding6397_18; - operand.values[19] = tokenCoding6397_19; + operand.values[16] = tokenCoding6403_16; + operand.values[17] = tokenCoding6403_17; + operand.values[18] = tokenCoding6403_18; + operand.values[19] = tokenCoding6403_19; } -x64Token x64Parser::tokenBranches6396[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6397, }, +x64Token x64Parser::tokenBranches6402[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6403, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6406_16[] = { +Coding x64Parser::tokenCoding6412_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_17[] = { +Coding x64Parser::tokenCoding6412_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_18[] = { +Coding x64Parser::tokenCoding6412_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6406_19[] = { +Coding x64Parser::tokenCoding6412_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6406(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6412(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6406_16; - operand.values[17] = tokenCoding6406_17; - operand.values[18] = tokenCoding6406_18; - operand.values[19] = tokenCoding6406_19; + operand.values[16] = tokenCoding6412_16; + operand.values[17] = tokenCoding6412_17; + operand.values[18] = tokenCoding6412_18; + operand.values[19] = tokenCoding6412_19; } -x64Token x64Parser::tokenBranches6405[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6406, }, +x64Token x64Parser::tokenBranches6411[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6412, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6408_16[] = { +Coding x64Parser::tokenCoding6414_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_17[] = { +Coding x64Parser::tokenCoding6414_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_18[] = { +Coding x64Parser::tokenCoding6414_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6408_19[] = { +Coding x64Parser::tokenCoding6414_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6408(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6408_16; - operand.values[17] = tokenCoding6408_17; - operand.values[18] = tokenCoding6408_18; - operand.values[19] = tokenCoding6408_19; + operand.values[16] = tokenCoding6414_16; + operand.values[17] = tokenCoding6414_17; + operand.values[18] = tokenCoding6414_18; + operand.values[19] = tokenCoding6414_19; } -x64Token x64Parser::tokenBranches6407[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6408, }, +x64Token x64Parser::tokenBranches6413[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6414, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6404_18[] = { +Coding x64Parser::tokenCoding6410_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6404_19[] = { +Coding x64Parser::tokenCoding6410_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6404(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6410(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6404_18; - operand.values[19] = tokenCoding6404_19; + operand.values[18] = tokenCoding6410_18; + operand.values[19] = tokenCoding6410_19; } -x64Token x64Parser::tokenBranches6403[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6404, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6405 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6407 }, +x64Token x64Parser::tokenBranches6409[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6410, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6411 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6413 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6411_16[] = { +Coding x64Parser::tokenCoding6417_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_17[] = { +Coding x64Parser::tokenCoding6417_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_18[] = { +Coding x64Parser::tokenCoding6417_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6411_19[] = { +Coding x64Parser::tokenCoding6417_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6411(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6417(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6411_16; - operand.values[17] = tokenCoding6411_17; - operand.values[18] = tokenCoding6411_18; - operand.values[19] = tokenCoding6411_19; + operand.values[16] = tokenCoding6417_16; + operand.values[17] = tokenCoding6417_17; + operand.values[18] = tokenCoding6417_18; + operand.values[19] = tokenCoding6417_19; } -x64Token x64Parser::tokenBranches6410[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6411, }, +x64Token x64Parser::tokenBranches6416[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6417, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6409[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6410 }, +x64Token x64Parser::tokenBranches6415[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6416 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6414_16[] = { +Coding x64Parser::tokenCoding6420_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_17[] = { +Coding x64Parser::tokenCoding6420_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_18[] = { +Coding x64Parser::tokenCoding6420_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6414_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc6414(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6414_16; - operand.values[17] = tokenCoding6414_17; - operand.values[18] = tokenCoding6414_18; - operand.values[19] = tokenCoding6414_19; -} -x64Token x64Parser::tokenBranches6413[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6414, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6412[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6413 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding6416_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6416_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding6420_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6416(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6416_16; - operand.values[17] = tokenCoding6416_17; - operand.values[18] = tokenCoding6416_18; - operand.values[19] = tokenCoding6416_19; + operand.values[16] = tokenCoding6420_16; + operand.values[17] = tokenCoding6420_17; + operand.values[18] = tokenCoding6420_18; + operand.values[19] = tokenCoding6420_19; } -x64Token x64Parser::tokenBranches6415[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6416, }, +x64Token x64Parser::tokenBranches6419[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6420, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6418_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding6418_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc6418(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6418_16; - operand.values[17] = tokenCoding6418_17; - operand.values[18] = tokenCoding6418_18; - operand.values[19] = tokenCoding6418_19; -} -x64Token x64Parser::tokenBranches6417[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6418, }, +x64Token x64Parser::tokenBranches6418[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6419 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding6422_16[] = { @@ -25239,11 +25253,12 @@ Coding x64Parser::tokenCoding6422_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6422_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6422_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) @@ -25254,7 +25269,7 @@ void x64Parser::TokenFunc6422(x64Operand &operand, int tokenPos) operand.values[19] = tokenCoding6422_19; } x64Token x64Parser::tokenBranches6421[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6422, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6422, }, {x64Token::EOT } }; Coding x64Parser::tokenCoding6424_16[] = { @@ -25266,11 +25281,11 @@ Coding x64Parser::tokenCoding6424_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6424_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding6424_19[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) @@ -25281,130 +25296,184 @@ void x64Parser::TokenFunc6424(x64Operand &operand, int tokenPos) operand.values[19] = tokenCoding6424_19; } x64Token x64Parser::tokenBranches6423[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6424, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6424, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6426_16[] = { +Coding x64Parser::tokenCoding6428_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_17[] = { +Coding x64Parser::tokenCoding6428_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_18[] = { +Coding x64Parser::tokenCoding6428_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6428_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6428(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6428_16; + operand.values[17] = tokenCoding6428_17; + operand.values[18] = tokenCoding6428_18; + operand.values[19] = tokenCoding6428_19; +} +x64Token x64Parser::tokenBranches6427[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6428, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6430_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6430_19[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +{ + operand.values[16] = tokenCoding6430_16; + operand.values[17] = tokenCoding6430_17; + operand.values[18] = tokenCoding6430_18; + operand.values[19] = tokenCoding6430_19; +} +x64Token x64Parser::tokenBranches6429[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6432_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6432_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding6432_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6426_19[] = { +Coding x64Parser::tokenCoding6432_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 219, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6432(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6426_16; - operand.values[17] = tokenCoding6426_17; - operand.values[18] = tokenCoding6426_18; - operand.values[19] = tokenCoding6426_19; + operand.values[16] = tokenCoding6432_16; + operand.values[17] = tokenCoding6432_17; + operand.values[18] = tokenCoding6432_18; + operand.values[19] = tokenCoding6432_19; } -x64Token x64Parser::tokenBranches6425[] = { - {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6426, }, +x64Token x64Parser::tokenBranches6431[] = { + {x64Token::ADDRESSCLASS, 2, 1, 0, NULL,&x64Parser::TokenFunc6432, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6420_18[] = { +Coding x64Parser::tokenCoding6426_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6420_19[] = { +Coding x64Parser::tokenCoding6426_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6420(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6426(x64Operand &operand, int tokenPos) { - operand.values[18] = tokenCoding6420_18; - operand.values[19] = tokenCoding6420_19; + operand.values[18] = tokenCoding6426_18; + operand.values[19] = tokenCoding6426_19; } -x64Token x64Parser::tokenBranches6419[] = { - {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6420, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6421 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6423 }, - {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6425 }, +x64Token x64Parser::tokenBranches6425[] = { + {x64Token::ADDRESSCLASS, 12, 1, 0, NULL,&x64Parser::TokenFunc6426, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6427 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6429 }, + {x64Token::TOKEN, 12, 0, 0, NULL, NULL, x64Parser::tokenBranches6431 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6429_16[] = { +Coding x64Parser::tokenCoding6435_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_17[] = { +Coding x64Parser::tokenCoding6435_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_18[] = { +Coding x64Parser::tokenCoding6435_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6429_19[] = { +Coding x64Parser::tokenCoding6435_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6429(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6435(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6429_16; - operand.values[17] = tokenCoding6429_17; - operand.values[18] = tokenCoding6429_18; - operand.values[19] = tokenCoding6429_19; + operand.values[16] = tokenCoding6435_16; + operand.values[17] = tokenCoding6435_17; + operand.values[18] = tokenCoding6435_18; + operand.values[19] = tokenCoding6435_19; } -x64Token x64Parser::tokenBranches6428[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6429, }, +x64Token x64Parser::tokenBranches6434[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6435, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6430(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6436(x64Operand &operand, int tokenPos) { - operand.operandCoding = 503; + operand.operandCoding = 504; } -x64Token x64Parser::tokenBranches6427[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6428 }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6430, }, +x64Token x64Parser::tokenBranches6433[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6434 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6436, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6433_16[] = { +Coding x64Parser::tokenCoding6439_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_17[] = { +Coding x64Parser::tokenCoding6439_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_18[] = { +Coding x64Parser::tokenCoding6439_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6433_19[] = { +Coding x64Parser::tokenCoding6439_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6433(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6439(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6433_16; - operand.values[17] = tokenCoding6433_17; - operand.values[18] = tokenCoding6433_18; - operand.values[19] = tokenCoding6433_19; + operand.values[16] = tokenCoding6439_16; + operand.values[17] = tokenCoding6439_17; + operand.values[18] = tokenCoding6439_18; + operand.values[19] = tokenCoding6439_19; } -x64Token x64Parser::tokenBranches6432[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6433, }, +x64Token x64Parser::tokenBranches6438[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6439, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6434(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6440(x64Operand &operand, int tokenPos) { - operand.operandCoding = 504; + operand.operandCoding = 505; } -x64Token x64Parser::tokenBranches6431[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6432 }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6434, }, +x64Token x64Parser::tokenBranches6437[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6438 }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc6440, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6450(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25417,19 +25486,19 @@ void x64Parser::TokenFunc6444(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6443[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6444, }, +x64Token x64Parser::tokenBranches6449[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6450, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6442[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6443 }, +x64Token x64Parser::tokenBranches6448[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6449 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6441[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6442 }, +x64Token x64Parser::tokenBranches6447[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6448 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6454(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25442,19 +25511,19 @@ void x64Parser::TokenFunc6448(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6447[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6448, }, +x64Token x64Parser::tokenBranches6453[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6454, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6446[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6447 }, +x64Token x64Parser::tokenBranches6452[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6453 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6445[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6446 }, +x64Token x64Parser::tokenBranches6451[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6452 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25467,19 +25536,19 @@ void x64Parser::TokenFunc6457(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6456[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6457, }, +x64Token x64Parser::tokenBranches6462[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6463, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6455[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6456 }, +x64Token x64Parser::tokenBranches6461[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6462 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6454[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6455 }, +x64Token x64Parser::tokenBranches6460[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6461 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6467(x64Operand &operand, int tokenPos) { operand.operandCoding = 462; operand.values[15] = new Coding[2]; @@ -25492,77 +25561,77 @@ void x64Parser::TokenFunc6461(x64Operand &operand, int tokenPos) operand.values[15]->binary = 0; operand.values[15][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6460[] = { - {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6461, }, +x64Token x64Parser::tokenBranches6466[] = { + {x64Token::REGISTERCLASS, 20, 1, 0, NULL,&x64Parser::TokenFunc6467, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6459[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6460 }, +x64Token x64Parser::tokenBranches6465[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6466 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6458[] = { - {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6459 }, +x64Token x64Parser::tokenBranches6464[] = { + {x64Token::REGISTER, 99, 0, 0, NULL, NULL, x64Parser::tokenBranches6465 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6463_16[] = { +Coding x64Parser::tokenCoding6469_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_17[] = { +Coding x64Parser::tokenCoding6469_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_18[] = { +Coding x64Parser::tokenCoding6469_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6463_19[] = { +Coding x64Parser::tokenCoding6469_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6463(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6469(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6463_16; - operand.values[17] = tokenCoding6463_17; - operand.values[18] = tokenCoding6463_18; - operand.values[19] = tokenCoding6463_19; + operand.values[16] = tokenCoding6469_16; + operand.values[17] = tokenCoding6469_17; + operand.values[18] = tokenCoding6469_18; + operand.values[19] = tokenCoding6469_19; } -x64Token x64Parser::tokenBranches6462[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6463, }, +x64Token x64Parser::tokenBranches6468[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6469, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6465_16[] = { +Coding x64Parser::tokenCoding6471_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_17[] = { +Coding x64Parser::tokenCoding6471_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_18[] = { +Coding x64Parser::tokenCoding6471_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6465_19[] = { +Coding x64Parser::tokenCoding6471_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 174, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6465(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6471(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6465_16; - operand.values[17] = tokenCoding6465_17; - operand.values[18] = tokenCoding6465_18; - operand.values[19] = tokenCoding6465_19; + operand.values[16] = tokenCoding6471_16; + operand.values[17] = tokenCoding6471_17; + operand.values[18] = tokenCoding6471_18; + operand.values[19] = tokenCoding6471_19; } -x64Token x64Parser::tokenBranches6464[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6465, }, +x64Token x64Parser::tokenBranches6470[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6471, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6482(x64Operand &operand, int tokenPos) { - operand.operandCoding = 505; + operand.operandCoding = 506; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25574,30 +25643,30 @@ void x64Parser::TokenFunc6476(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6475[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6476, }, +x64Token x64Parser::tokenBranches6481[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6482, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6503_16[] = { +Coding x64Parser::tokenCoding6509_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_17[] = { +Coding x64Parser::tokenCoding6509_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_18[] = { +Coding x64Parser::tokenCoding6509_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6503_19[] = { +Coding x64Parser::tokenCoding6509_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 4 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25608,35 +25677,35 @@ void x64Parser::TokenFunc6503(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6503_16; - operand.values[17] = tokenCoding6503_17; - operand.values[18] = tokenCoding6503_18; - operand.values[19] = tokenCoding6503_19; + operand.values[16] = tokenCoding6509_16; + operand.values[17] = tokenCoding6509_17; + operand.values[18] = tokenCoding6509_18; + operand.values[19] = tokenCoding6509_19; } -x64Token x64Parser::tokenBranches6502[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6503, }, +x64Token x64Parser::tokenBranches6508[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6509, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6509_16[] = { +Coding x64Parser::tokenCoding6515_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_17[] = { +Coding x64Parser::tokenCoding6515_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_18[] = { +Coding x64Parser::tokenCoding6515_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6509_19[] = { +Coding x64Parser::tokenCoding6515_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6515(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25647,23 +25716,23 @@ void x64Parser::TokenFunc6509(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6509_16; - operand.values[17] = tokenCoding6509_17; - operand.values[18] = tokenCoding6509_18; - operand.values[19] = tokenCoding6509_19; + operand.values[16] = tokenCoding6515_16; + operand.values[17] = tokenCoding6515_17; + operand.values[18] = tokenCoding6515_18; + operand.values[19] = tokenCoding6515_19; } -x64Token x64Parser::tokenBranches6501[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6502 }, - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6509, }, +x64Token x64Parser::tokenBranches6507[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6508 }, + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6515, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6500[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6501 }, +x64Token x64Parser::tokenBranches6506[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6507 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6486(x64Operand &operand, int tokenPos) { - operand.operandCoding = 506; + operand.operandCoding = 507; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25675,48 +25744,48 @@ void x64Parser::TokenFunc6480(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6500_16[] = { +Coding x64Parser::tokenCoding6506_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_17[] = { +Coding x64Parser::tokenCoding6506_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_18[] = { +Coding x64Parser::tokenCoding6506_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6500_19[] = { +Coding x64Parser::tokenCoding6506_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6500(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6506(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6500_16; - operand.values[17] = tokenCoding6500_17; - operand.values[18] = tokenCoding6500_18; - operand.values[19] = tokenCoding6500_19; + operand.values[16] = tokenCoding6506_16; + operand.values[17] = tokenCoding6506_17; + operand.values[18] = tokenCoding6506_18; + operand.values[19] = tokenCoding6506_19; } -x64Token x64Parser::tokenBranches6479[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6480, }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6500, x64Parser::tokenBranches6500 }, +x64Token x64Parser::tokenBranches6485[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc6486, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc6506, x64Parser::tokenBranches6506 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6474[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6475 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6479 }, +x64Token x64Parser::tokenBranches6480[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6481 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6485 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6473[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6474 }, +x64Token x64Parser::tokenBranches6479[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6480 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6490(x64Operand &operand, int tokenPos) { - operand.operandCoding = 507; + operand.operandCoding = 508; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25728,30 +25797,30 @@ void x64Parser::TokenFunc6484(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6483[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6484, }, +x64Token x64Parser::tokenBranches6489[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6490, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6520_16[] = { +Coding x64Parser::tokenCoding6526_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_17[] = { +Coding x64Parser::tokenCoding6526_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_18[] = { +Coding x64Parser::tokenCoding6526_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6520_19[] = { +Coding x64Parser::tokenCoding6526_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 5 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25762,35 +25831,35 @@ void x64Parser::TokenFunc6520(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6520_16; - operand.values[17] = tokenCoding6520_17; - operand.values[18] = tokenCoding6520_18; - operand.values[19] = tokenCoding6520_19; + operand.values[16] = tokenCoding6526_16; + operand.values[17] = tokenCoding6526_17; + operand.values[18] = tokenCoding6526_18; + operand.values[19] = tokenCoding6526_19; } -x64Token x64Parser::tokenBranches6519[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6520, }, +x64Token x64Parser::tokenBranches6525[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6526, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6526_16[] = { +Coding x64Parser::tokenCoding6532_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_17[] = { +Coding x64Parser::tokenCoding6532_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_18[] = { +Coding x64Parser::tokenCoding6532_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6526_19[] = { +Coding x64Parser::tokenCoding6532_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6532(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25801,23 +25870,23 @@ void x64Parser::TokenFunc6526(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6526_16; - operand.values[17] = tokenCoding6526_17; - operand.values[18] = tokenCoding6526_18; - operand.values[19] = tokenCoding6526_19; + operand.values[16] = tokenCoding6532_16; + operand.values[17] = tokenCoding6532_17; + operand.values[18] = tokenCoding6532_18; + operand.values[19] = tokenCoding6532_19; } -x64Token x64Parser::tokenBranches6518[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6519 }, - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6526, }, +x64Token x64Parser::tokenBranches6524[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6525 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6532, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6517[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6518 }, +x64Token x64Parser::tokenBranches6523[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6524 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6494(x64Operand &operand, int tokenPos) { - operand.operandCoding = 508; + operand.operandCoding = 509; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25829,48 +25898,48 @@ void x64Parser::TokenFunc6488(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6517_16[] = { +Coding x64Parser::tokenCoding6523_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_17[] = { +Coding x64Parser::tokenCoding6523_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_18[] = { +Coding x64Parser::tokenCoding6523_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6517_19[] = { +Coding x64Parser::tokenCoding6523_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6517(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6523(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6517_16; - operand.values[17] = tokenCoding6517_17; - operand.values[18] = tokenCoding6517_18; - operand.values[19] = tokenCoding6517_19; + operand.values[16] = tokenCoding6523_16; + operand.values[17] = tokenCoding6523_17; + operand.values[18] = tokenCoding6523_18; + operand.values[19] = tokenCoding6523_19; } -x64Token x64Parser::tokenBranches6487[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6488, }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6517, x64Parser::tokenBranches6517 }, +x64Token x64Parser::tokenBranches6493[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6494, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc6523, x64Parser::tokenBranches6523 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6482[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6483 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6487 }, +x64Token x64Parser::tokenBranches6488[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6489 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6493 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6481[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6482 }, +x64Token x64Parser::tokenBranches6487[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6488 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6498(x64Operand &operand, int tokenPos) { - operand.operandCoding = 509; + operand.operandCoding = 510; operand.values[24] = new Coding[2]; CleanupValues.push_back(operand.values[24]); operand.values[24]->type = Coding::number; @@ -25882,30 +25951,30 @@ void x64Parser::TokenFunc6492(x64Operand &operand, int tokenPos) operand.values[24][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6491[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6492, }, +x64Token x64Parser::tokenBranches6497[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6498, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6537_16[] = { +Coding x64Parser::tokenCoding6543_16[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_17[] = { +Coding x64Parser::tokenCoding6543_17[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_18[] = { +Coding x64Parser::tokenCoding6543_18[] = { { CODING_NAME("isigned") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6537_19[] = { +Coding x64Parser::tokenCoding6543_19[] = { { CODING_NAME("isigned") Coding::stateFunc, 6 }, { CODING_NAME("isigned") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) { - operand.operandCoding = 511; + operand.operandCoding = 512; operand.values[28] = new Coding[2]; CleanupValues.push_back(operand.values[28]); operand.values[28]->type = Coding::number; @@ -25916,35 +25985,35 @@ void x64Parser::TokenFunc6537(x64Operand &operand, int tokenPos) operand.values[28]->binary = 0; operand.values[28][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6537_16; - operand.values[17] = tokenCoding6537_17; - operand.values[18] = tokenCoding6537_18; - operand.values[19] = tokenCoding6537_19; + operand.values[16] = tokenCoding6543_16; + operand.values[17] = tokenCoding6543_17; + operand.values[18] = tokenCoding6543_18; + operand.values[19] = tokenCoding6543_19; } -x64Token x64Parser::tokenBranches6536[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6537, }, +x64Token x64Parser::tokenBranches6542[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc6543, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6543_16[] = { +Coding x64Parser::tokenCoding6549_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_17[] = { +Coding x64Parser::tokenCoding6549_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_18[] = { +Coding x64Parser::tokenCoding6549_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6543_19[] = { +Coding x64Parser::tokenCoding6549_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25955,23 +26024,23 @@ void x64Parser::TokenFunc6543(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding6543_16; - operand.values[17] = tokenCoding6543_17; - operand.values[18] = tokenCoding6543_18; - operand.values[19] = tokenCoding6543_19; + operand.values[16] = tokenCoding6549_16; + operand.values[17] = tokenCoding6549_17; + operand.values[18] = tokenCoding6549_18; + operand.values[19] = tokenCoding6549_19; } -x64Token x64Parser::tokenBranches6535[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6536 }, - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6543, }, +x64Token x64Parser::tokenBranches6541[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6542 }, + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6549, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6534[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6535 }, +x64Token x64Parser::tokenBranches6540[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6541 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6502(x64Operand &operand, int tokenPos) { - operand.operandCoding = 510; + operand.operandCoding = 511; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -25983,157 +26052,157 @@ void x64Parser::TokenFunc6496(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6534_16[] = { +Coding x64Parser::tokenCoding6540_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_17[] = { +Coding x64Parser::tokenCoding6540_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_18[] = { +Coding x64Parser::tokenCoding6540_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6534_19[] = { +Coding x64Parser::tokenCoding6540_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6534(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6540(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6534_16; - operand.values[17] = tokenCoding6534_17; - operand.values[18] = tokenCoding6534_18; - operand.values[19] = tokenCoding6534_19; + operand.values[16] = tokenCoding6540_16; + operand.values[17] = tokenCoding6540_17; + operand.values[18] = tokenCoding6540_18; + operand.values[19] = tokenCoding6540_19; } -x64Token x64Parser::tokenBranches6495[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6496, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6534, x64Parser::tokenBranches6534 }, +x64Token x64Parser::tokenBranches6501[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc6502, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc6540, x64Parser::tokenBranches6540 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6490[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6491 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6495 }, +x64Token x64Parser::tokenBranches6496[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6497 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches6501 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6489[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6490 }, +x64Token x64Parser::tokenBranches6495[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6496 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6549_16[] = { +Coding x64Parser::tokenCoding6555_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_17[] = { +Coding x64Parser::tokenCoding6555_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_18[] = { +Coding x64Parser::tokenCoding6555_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6549_19[] = { +Coding x64Parser::tokenCoding6555_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6549(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6549_16; - operand.values[17] = tokenCoding6549_17; - operand.values[18] = tokenCoding6549_18; - operand.values[19] = tokenCoding6549_19; + operand.values[16] = tokenCoding6555_16; + operand.values[17] = tokenCoding6555_17; + operand.values[18] = tokenCoding6555_18; + operand.values[19] = tokenCoding6555_19; } -x64Token x64Parser::tokenBranches6548[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6549, }, +x64Token x64Parser::tokenBranches6554[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6551_16[] = { +Coding x64Parser::tokenCoding6557_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_17[] = { +Coding x64Parser::tokenCoding6557_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_18[] = { +Coding x64Parser::tokenCoding6557_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6551_19[] = { +Coding x64Parser::tokenCoding6557_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6551(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6557(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6551_16; - operand.values[17] = tokenCoding6551_17; - operand.values[18] = tokenCoding6551_18; - operand.values[19] = tokenCoding6551_19; + operand.values[16] = tokenCoding6557_16; + operand.values[17] = tokenCoding6557_17; + operand.values[18] = tokenCoding6557_18; + operand.values[19] = tokenCoding6557_19; } -x64Token x64Parser::tokenBranches6550[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6551, }, +x64Token x64Parser::tokenBranches6556[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6557, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6553_16[] = { +Coding x64Parser::tokenCoding6559_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_17[] = { +Coding x64Parser::tokenCoding6559_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_18[] = { +Coding x64Parser::tokenCoding6559_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6553_19[] = { +Coding x64Parser::tokenCoding6559_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6553(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6559(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6553_16; - operand.values[17] = tokenCoding6553_17; - operand.values[18] = tokenCoding6553_18; - operand.values[19] = tokenCoding6553_19; + operand.values[16] = tokenCoding6559_16; + operand.values[17] = tokenCoding6559_17; + operand.values[18] = tokenCoding6559_18; + operand.values[19] = tokenCoding6559_19; } -x64Token x64Parser::tokenBranches6552[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6553, }, +x64Token x64Parser::tokenBranches6558[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6559, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6555_16[] = { +Coding x64Parser::tokenCoding6561_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_17[] = { +Coding x64Parser::tokenCoding6561_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_18[] = { +Coding x64Parser::tokenCoding6561_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6555_19[] = { +Coding x64Parser::tokenCoding6561_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6555(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6561(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6555_16; - operand.values[17] = tokenCoding6555_17; - operand.values[18] = tokenCoding6555_18; - operand.values[19] = tokenCoding6555_19; + operand.values[16] = tokenCoding6561_16; + operand.values[17] = tokenCoding6561_17; + operand.values[18] = tokenCoding6561_18; + operand.values[19] = tokenCoding6561_19; } -x64Token x64Parser::tokenBranches6554[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6555, }, +x64Token x64Parser::tokenBranches6560[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6561, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6479(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26145,7 +26214,7 @@ void x64Parser::TokenFunc6473(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6487(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26157,7 +26226,7 @@ void x64Parser::TokenFunc6481(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6495(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -26169,19 +26238,19 @@ void x64Parser::TokenFunc6489(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6472[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6473, x64Parser::tokenBranches6473 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6481, x64Parser::tokenBranches6481 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6489, x64Parser::tokenBranches6489 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6548 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6550 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6552 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, +x64Token x64Parser::tokenBranches6478[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc6479, x64Parser::tokenBranches6479 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc6487, x64Parser::tokenBranches6487 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc6495, x64Parser::tokenBranches6495 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6554 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6556 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6560 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6566(x64Operand &operand, int tokenPos) { - operand.operandCoding = 514; + operand.operandCoding = 515; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26193,26 +26262,26 @@ void x64Parser::TokenFunc6560(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6559[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6560, }, +x64Token x64Parser::tokenBranches6565[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6566, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6575(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) { - operand.operandCoding = 518; + operand.operandCoding = 519; } -x64Token x64Parser::tokenBranches6558[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6559 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6575, }, +x64Token x64Parser::tokenBranches6564[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6565 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6557[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6558 }, +x64Token x64Parser::tokenBranches6563[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6564 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6570(x64Operand &operand, int tokenPos) { - operand.operandCoding = 515; + operand.operandCoding = 516; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26224,26 +26293,26 @@ void x64Parser::TokenFunc6564(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6563[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6564, }, +x64Token x64Parser::tokenBranches6569[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6570, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) { - operand.operandCoding = 519; + operand.operandCoding = 520; } -x64Token x64Parser::tokenBranches6562[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6563 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6578, }, +x64Token x64Parser::tokenBranches6568[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6569 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6561[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6562 }, +x64Token x64Parser::tokenBranches6567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6568 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6574(x64Operand &operand, int tokenPos) { - operand.operandCoding = 516; + operand.operandCoding = 517; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26255,26 +26324,26 @@ void x64Parser::TokenFunc6568(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6567[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6568, }, +x64Token x64Parser::tokenBranches6573[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6574, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6581(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6587(x64Operand &operand, int tokenPos) { - operand.operandCoding = 520; + operand.operandCoding = 521; } -x64Token x64Parser::tokenBranches6566[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6567 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6581, }, +x64Token x64Parser::tokenBranches6572[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6573 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6587, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6565[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6566 }, +x64Token x64Parser::tokenBranches6571[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6572 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6578(x64Operand &operand, int tokenPos) { - operand.operandCoding = 517; + operand.operandCoding = 518; operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); operand.values[29]->type = Coding::number; @@ -26286,150 +26355,150 @@ void x64Parser::TokenFunc6572(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6571[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6572, }, +x64Token x64Parser::tokenBranches6577[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6578, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6584(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6590(x64Operand &operand, int tokenPos) { - operand.operandCoding = 521; + operand.operandCoding = 522; } -x64Token x64Parser::tokenBranches6570[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6571 }, - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6584, }, +x64Token x64Parser::tokenBranches6576[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6577 }, + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6590, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6569[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6570 }, +x64Token x64Parser::tokenBranches6575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6576 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6556[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6557 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6561 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6565 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6569 }, +x64Token x64Parser::tokenBranches6562[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6563 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6567 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6571 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches6575 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6599(x64Operand &operand, int tokenPos) { - operand.operandCoding = 522; + operand.operandCoding = 523; } -x64Token x64Parser::tokenBranches6592[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6593, }, +x64Token x64Parser::tokenBranches6598[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6599, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6591[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, +x64Token x64Parser::tokenBranches6597[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6590[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6591 }, +x64Token x64Parser::tokenBranches6596[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6609(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6615(x64Operand &operand, int tokenPos) { - operand.operandCoding = 524; + operand.operandCoding = 525; } -x64Token x64Parser::tokenBranches6608[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6609, }, +x64Token x64Parser::tokenBranches6614[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6615, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6607[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6608 }, +x64Token x64Parser::tokenBranches6613[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6606[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6607 }, +x64Token x64Parser::tokenBranches6612[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6613 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6589[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6590 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, +x64Token x64Parser::tokenBranches6595[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6596 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6612 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6588[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6589 }, +x64Token x64Parser::tokenBranches6594[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6587[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6588 }, +x64Token x64Parser::tokenBranches6593[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6594 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6601(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6607(x64Operand &operand, int tokenPos) { - operand.operandCoding = 523; + operand.operandCoding = 524; } -x64Token x64Parser::tokenBranches6600[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6601, }, +x64Token x64Parser::tokenBranches6606[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6607, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6599[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6600 }, +x64Token x64Parser::tokenBranches6605[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6606 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6598[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6599 }, +x64Token x64Parser::tokenBranches6604[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6605 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6617(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) { - operand.operandCoding = 525; + operand.operandCoding = 526; } -x64Token x64Parser::tokenBranches6616[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6617, }, +x64Token x64Parser::tokenBranches6622[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6615[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6616 }, +x64Token x64Parser::tokenBranches6621[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6614[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6615 }, +x64Token x64Parser::tokenBranches6620[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6631(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6637(x64Operand &operand, int tokenPos) { - operand.operandCoding = 527; + operand.operandCoding = 528; } -x64Token x64Parser::tokenBranches6630[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6631, }, +x64Token x64Parser::tokenBranches6636[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6637, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6629[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6630 }, +x64Token x64Parser::tokenBranches6635[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6628[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6629 }, +x64Token x64Parser::tokenBranches6634[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6597[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6598 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6614 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, +x64Token x64Parser::tokenBranches6603[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6604 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6596[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6597 }, +x64Token x64Parser::tokenBranches6602[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6603 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6623(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6629(x64Operand &operand, int tokenPos) { - operand.operandCoding = 526; + operand.operandCoding = 527; } -x64Token x64Parser::tokenBranches6622[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6623, }, +x64Token x64Parser::tokenBranches6628[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6629, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6621[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6622 }, +x64Token x64Parser::tokenBranches6627[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6628 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6620[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6621 }, +x64Token x64Parser::tokenBranches6626[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6627 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6602(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26441,136 +26510,136 @@ void x64Parser::TokenFunc6596(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6595[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6596, x64Parser::tokenBranches6596 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6620 }, +x64Token x64Parser::tokenBranches6601[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6602, x64Parser::tokenBranches6602 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6626 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6586[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6587 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6595 }, +x64Token x64Parser::tokenBranches6592[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6593 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6601 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6639(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6645(x64Operand &operand, int tokenPos) { - operand.operandCoding = 528; + operand.operandCoding = 529; } -x64Token x64Parser::tokenBranches6638[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6639, }, +x64Token x64Parser::tokenBranches6644[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6645, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6637[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, +x64Token x64Parser::tokenBranches6643[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6636[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6637 }, +x64Token x64Parser::tokenBranches6642[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6655(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6661(x64Operand &operand, int tokenPos) { - operand.operandCoding = 530; + operand.operandCoding = 531; } -x64Token x64Parser::tokenBranches6654[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6655, }, +x64Token x64Parser::tokenBranches6660[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6661, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6653[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6654 }, +x64Token x64Parser::tokenBranches6659[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6652[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6653 }, +x64Token x64Parser::tokenBranches6658[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6659 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6635[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6636 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, +x64Token x64Parser::tokenBranches6641[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6642 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6658 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6634[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6635 }, +x64Token x64Parser::tokenBranches6640[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6633[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6634 }, +x64Token x64Parser::tokenBranches6639[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6640 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6647(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6653(x64Operand &operand, int tokenPos) { - operand.operandCoding = 529; + operand.operandCoding = 530; } -x64Token x64Parser::tokenBranches6646[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6647, }, +x64Token x64Parser::tokenBranches6652[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6653, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6645[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6646 }, +x64Token x64Parser::tokenBranches6651[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6652 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6644[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6645 }, +x64Token x64Parser::tokenBranches6650[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6651 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6663(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) { - operand.operandCoding = 531; + operand.operandCoding = 532; } -x64Token x64Parser::tokenBranches6662[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6663, }, +x64Token x64Parser::tokenBranches6668[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6661[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6662 }, +x64Token x64Parser::tokenBranches6667[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6660[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6661 }, +x64Token x64Parser::tokenBranches6666[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6677(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6683(x64Operand &operand, int tokenPos) { - operand.operandCoding = 533; + operand.operandCoding = 534; } -x64Token x64Parser::tokenBranches6676[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6677, }, +x64Token x64Parser::tokenBranches6682[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6683, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6675[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6676 }, +x64Token x64Parser::tokenBranches6681[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6674[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6675 }, +x64Token x64Parser::tokenBranches6680[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6643[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6644 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6660 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, +x64Token x64Parser::tokenBranches6649[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6650 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6642[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6643 }, +x64Token x64Parser::tokenBranches6648[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6649 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6669(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6675(x64Operand &operand, int tokenPos) { - operand.operandCoding = 532; + operand.operandCoding = 533; } -x64Token x64Parser::tokenBranches6668[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6669, }, +x64Token x64Parser::tokenBranches6674[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6675, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6667[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6668 }, +x64Token x64Parser::tokenBranches6673[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6674 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6666[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6667 }, +x64Token x64Parser::tokenBranches6672[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6673 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6648(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26582,136 +26651,136 @@ void x64Parser::TokenFunc6642(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6641[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6642, x64Parser::tokenBranches6642 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6666 }, +x64Token x64Parser::tokenBranches6647[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6648, x64Parser::tokenBranches6648 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6672 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6632[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6633 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6641 }, +x64Token x64Parser::tokenBranches6638[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6639 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6647 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6685(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6691(x64Operand &operand, int tokenPos) { - operand.operandCoding = 534; + operand.operandCoding = 535; } -x64Token x64Parser::tokenBranches6684[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6685, }, +x64Token x64Parser::tokenBranches6690[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6691, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6683[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, +x64Token x64Parser::tokenBranches6689[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6682[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6683 }, +x64Token x64Parser::tokenBranches6688[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6701(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6707(x64Operand &operand, int tokenPos) { - operand.operandCoding = 536; + operand.operandCoding = 537; } -x64Token x64Parser::tokenBranches6700[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6701, }, +x64Token x64Parser::tokenBranches6706[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6707, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6699[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6700 }, +x64Token x64Parser::tokenBranches6705[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6698[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6699 }, +x64Token x64Parser::tokenBranches6704[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6705 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6681[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6682 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, +x64Token x64Parser::tokenBranches6687[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6688 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6704 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6680[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6681 }, +x64Token x64Parser::tokenBranches6686[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6679[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6680 }, +x64Token x64Parser::tokenBranches6685[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6686 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6693(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6699(x64Operand &operand, int tokenPos) { - operand.operandCoding = 535; + operand.operandCoding = 536; } -x64Token x64Parser::tokenBranches6692[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6693, }, +x64Token x64Parser::tokenBranches6698[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6699, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6691[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6692 }, +x64Token x64Parser::tokenBranches6697[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6698 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6690[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6691 }, +x64Token x64Parser::tokenBranches6696[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6697 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6709(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) { - operand.operandCoding = 537; + operand.operandCoding = 538; } -x64Token x64Parser::tokenBranches6708[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6709, }, +x64Token x64Parser::tokenBranches6714[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6707[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6708 }, +x64Token x64Parser::tokenBranches6713[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6706[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6707 }, +x64Token x64Parser::tokenBranches6712[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6723(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6729(x64Operand &operand, int tokenPos) { - operand.operandCoding = 539; + operand.operandCoding = 540; } -x64Token x64Parser::tokenBranches6722[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6723, }, +x64Token x64Parser::tokenBranches6728[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6729, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6721[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6722 }, +x64Token x64Parser::tokenBranches6727[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6728 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6720[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6721 }, +x64Token x64Parser::tokenBranches6726[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6727 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6689[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6690 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6706 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, +x64Token x64Parser::tokenBranches6695[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches6696 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6726 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6688[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6689 }, +x64Token x64Parser::tokenBranches6694[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6695 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6715(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6721(x64Operand &operand, int tokenPos) { - operand.operandCoding = 538; + operand.operandCoding = 539; } -x64Token x64Parser::tokenBranches6714[] = { - {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6715, }, +x64Token x64Parser::tokenBranches6720[] = { + {x64Token::REGISTER, 20, 1, 0, NULL,&x64Parser::TokenFunc6721, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6713[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6714 }, +x64Token x64Parser::tokenBranches6719[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6720 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6712[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6713 }, +x64Token x64Parser::tokenBranches6718[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches6719 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6694(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26723,25 +26792,25 @@ void x64Parser::TokenFunc6688(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6687[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6688, x64Parser::tokenBranches6688 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6712 }, +x64Token x64Parser::tokenBranches6693[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6694, x64Parser::tokenBranches6694 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches6718 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6678[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6679 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6687 }, +x64Token x64Parser::tokenBranches6684[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches6685 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6693 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6585[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6586 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6632 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6678 }, +x64Token x64Parser::tokenBranches6591[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6592 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6638 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6684 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) { - operand.operandCoding = 540; + operand.operandCoding = 541; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26753,53 +26822,53 @@ void x64Parser::TokenFunc6730(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6729[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6730, }, +x64Token x64Parser::tokenBranches6735[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc6736, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6728[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6729 }, +x64Token x64Parser::tokenBranches6734[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6735 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6736_16[] = { +Coding x64Parser::tokenCoding6742_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_17[] = { +Coding x64Parser::tokenCoding6742_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_18[] = { +Coding x64Parser::tokenCoding6742_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6736_19[] = { +Coding x64Parser::tokenCoding6742_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6736(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6742(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6736_16; - operand.values[17] = tokenCoding6736_17; - operand.values[18] = tokenCoding6736_18; - operand.values[19] = tokenCoding6736_19; + operand.values[16] = tokenCoding6742_16; + operand.values[17] = tokenCoding6742_17; + operand.values[18] = tokenCoding6742_18; + operand.values[19] = tokenCoding6742_19; } -x64Token x64Parser::tokenBranches6735[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6736, }, +x64Token x64Parser::tokenBranches6741[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6742, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6740(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6746(x64Operand &operand, int tokenPos) { - operand.operandCoding = 541; + operand.operandCoding = 542; } -x64Token x64Parser::tokenBranches6739[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6740, }, +x64Token x64Parser::tokenBranches6745[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6746, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6754(x64Operand &operand, int tokenPos) { - operand.operandCoding = 542; + operand.operandCoding = 543; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -26811,13 +26880,13 @@ void x64Parser::TokenFunc6748(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6747[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6748, }, +x64Token x64Parser::tokenBranches6753[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6754, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6756(x64Operand &operand, int tokenPos) { - operand.operandCoding = 543; + operand.operandCoding = 544; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -26829,13 +26898,13 @@ void x64Parser::TokenFunc6750(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6749[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6750, }, +x64Token x64Parser::tokenBranches6755[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6756, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6767(x64Operand &operand, int tokenPos) { - operand.operandCoding = 544; + operand.operandCoding = 545; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26847,13 +26916,13 @@ void x64Parser::TokenFunc6761(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6760[] = { - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6761, }, +x64Token x64Parser::tokenBranches6766[] = { + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6767, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) { - operand.operandCoding = 545; + operand.operandCoding = 546; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26865,76 +26934,76 @@ void x64Parser::TokenFunc6766(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6765[] = { - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6766, }, +x64Token x64Parser::tokenBranches6771[] = { + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6772, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6759[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6760 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6765 }, +x64Token x64Parser::tokenBranches6765[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches6766 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches6771 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6758[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6759 }, +x64Token x64Parser::tokenBranches6764[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6765 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6775_16[] = { +Coding x64Parser::tokenCoding6781_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_17[] = { +Coding x64Parser::tokenCoding6781_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_18[] = { +Coding x64Parser::tokenCoding6781_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6775_19[] = { +Coding x64Parser::tokenCoding6781_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6775(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6781(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6775_16; - operand.values[17] = tokenCoding6775_17; - operand.values[18] = tokenCoding6775_18; - operand.values[19] = tokenCoding6775_19; + operand.values[16] = tokenCoding6781_16; + operand.values[17] = tokenCoding6781_17; + operand.values[18] = tokenCoding6781_18; + operand.values[19] = tokenCoding6781_19; } -x64Token x64Parser::tokenBranches6774[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6775, }, +x64Token x64Parser::tokenBranches6780[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6781, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6778_16[] = { +Coding x64Parser::tokenCoding6784_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_17[] = { +Coding x64Parser::tokenCoding6784_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_18[] = { +Coding x64Parser::tokenCoding6784_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6778_19[] = { +Coding x64Parser::tokenCoding6784_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6778_16; - operand.values[17] = tokenCoding6778_17; - operand.values[18] = tokenCoding6778_18; - operand.values[19] = tokenCoding6778_19; + operand.values[16] = tokenCoding6784_16; + operand.values[17] = tokenCoding6784_17; + operand.values[18] = tokenCoding6784_18; + operand.values[19] = tokenCoding6784_19; } -x64Token x64Parser::tokenBranches6777[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, +x64Token x64Parser::tokenBranches6783[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6784, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6764(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -26947,9 +27016,9 @@ void x64Parser::TokenFunc6758(x64Operand &operand, int tokenPos) operand.values[2][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6774(x64Operand &operand, int tokenPos) { - operand.operandCoding = 546; + operand.operandCoding = 547; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26961,9 +27030,9 @@ void x64Parser::TokenFunc6768(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6776(x64Operand &operand, int tokenPos) { - operand.operandCoding = 547; + operand.operandCoding = 548; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -26975,41 +27044,41 @@ void x64Parser::TokenFunc6770(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6772_16[] = { +Coding x64Parser::tokenCoding6778_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_17[] = { +Coding x64Parser::tokenCoding6778_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_18[] = { +Coding x64Parser::tokenCoding6778_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6772_19[] = { +Coding x64Parser::tokenCoding6778_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6772(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6778(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6772_16; - operand.values[17] = tokenCoding6772_17; - operand.values[18] = tokenCoding6772_18; - operand.values[19] = tokenCoding6772_19; + operand.values[16] = tokenCoding6778_16; + operand.values[17] = tokenCoding6778_17; + operand.values[18] = tokenCoding6778_18; + operand.values[19] = tokenCoding6778_19; } -x64Token x64Parser::tokenBranches6757[] = { - {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6758, x64Parser::tokenBranches6758 }, - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6768, }, - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6770, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6772, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6774 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6777 }, +x64Token x64Parser::tokenBranches6763[] = { + {x64Token::NUMBER, 4, 0, 0, NULL,&x64Parser::TokenFunc6764, x64Parser::tokenBranches6764 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc6774, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc6776, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6778, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6780 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6783 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) { - operand.operandCoding = 548; + operand.operandCoding = 549; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27021,13 +27090,13 @@ void x64Parser::TokenFunc6780(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6779[] = { - {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6780, }, +x64Token x64Parser::tokenBranches6785[] = { + {x64Token::NUMBER, 9, 1, 0, NULL,&x64Parser::TokenFunc6786, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) { - operand.operandCoding = 549; + operand.operandCoding = 550; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27039,9 +27108,9 @@ void x64Parser::TokenFunc6782(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) { - operand.operandCoding = 550; + operand.operandCoding = 551; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27053,98 +27122,98 @@ void x64Parser::TokenFunc6784(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6781[] = { - {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6782, }, - {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6784, }, +x64Token x64Parser::tokenBranches6787[] = { + {x64Token::NUMBER, 14, 1, 0, NULL,&x64Parser::TokenFunc6788, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6790, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6792_16[] = { +Coding x64Parser::tokenCoding6798_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_17[] = { +Coding x64Parser::tokenCoding6798_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_18[] = { +Coding x64Parser::tokenCoding6798_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6792_19[] = { +Coding x64Parser::tokenCoding6798_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6798(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6792_16; - operand.values[17] = tokenCoding6792_17; - operand.values[18] = tokenCoding6792_18; - operand.values[19] = tokenCoding6792_19; + operand.values[16] = tokenCoding6798_16; + operand.values[17] = tokenCoding6798_17; + operand.values[18] = tokenCoding6798_18; + operand.values[19] = tokenCoding6798_19; } -x64Token x64Parser::tokenBranches6791[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6792, }, +x64Token x64Parser::tokenBranches6797[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6798, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6794_16[] = { +Coding x64Parser::tokenCoding6800_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_17[] = { +Coding x64Parser::tokenCoding6800_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_18[] = { +Coding x64Parser::tokenCoding6800_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6794_19[] = { +Coding x64Parser::tokenCoding6800_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6800(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6794_16; - operand.values[17] = tokenCoding6794_17; - operand.values[18] = tokenCoding6794_18; - operand.values[19] = tokenCoding6794_19; + operand.values[16] = tokenCoding6800_16; + operand.values[17] = tokenCoding6800_17; + operand.values[18] = tokenCoding6800_18; + operand.values[19] = tokenCoding6800_19; } -x64Token x64Parser::tokenBranches6793[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6794, }, +x64Token x64Parser::tokenBranches6799[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6800, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6796_16[] = { +Coding x64Parser::tokenCoding6802_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_17[] = { +Coding x64Parser::tokenCoding6802_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_18[] = { +Coding x64Parser::tokenCoding6802_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6796_19[] = { +Coding x64Parser::tokenCoding6802_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6802(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6796_16; - operand.values[17] = tokenCoding6796_17; - operand.values[18] = tokenCoding6796_18; - operand.values[19] = tokenCoding6796_19; + operand.values[16] = tokenCoding6802_16; + operand.values[17] = tokenCoding6802_17; + operand.values[18] = tokenCoding6802_18; + operand.values[19] = tokenCoding6802_19; } -x64Token x64Parser::tokenBranches6795[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, +x64Token x64Parser::tokenBranches6801[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6802, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6791(x64Operand &operand, int tokenPos) { - operand.operandCoding = 549; + operand.operandCoding = 550; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27156,9 +27225,9 @@ void x64Parser::TokenFunc6785(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6792(x64Operand &operand, int tokenPos) { - operand.operandCoding = 550; + operand.operandCoding = 551; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27170,167 +27239,142 @@ void x64Parser::TokenFunc6786(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding6787_16[] = { +Coding x64Parser::tokenCoding6793_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_17[] = { +Coding x64Parser::tokenCoding6793_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_18[] = { +Coding x64Parser::tokenCoding6793_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6787_19[] = { +Coding x64Parser::tokenCoding6793_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6787(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6793(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6787_16; - operand.values[17] = tokenCoding6787_17; - operand.values[18] = tokenCoding6787_18; - operand.values[19] = tokenCoding6787_19; + operand.values[16] = tokenCoding6793_16; + operand.values[17] = tokenCoding6793_17; + operand.values[18] = tokenCoding6793_18; + operand.values[19] = tokenCoding6793_19; } -Coding x64Parser::tokenCoding6788_16[] = { +Coding x64Parser::tokenCoding6794_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_17[] = { +Coding x64Parser::tokenCoding6794_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_18[] = { +Coding x64Parser::tokenCoding6794_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6788_19[] = { +Coding x64Parser::tokenCoding6794_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6788(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6794(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6788_16; - operand.values[17] = tokenCoding6788_17; - operand.values[18] = tokenCoding6788_18; - operand.values[19] = tokenCoding6788_19; + operand.values[16] = tokenCoding6794_16; + operand.values[17] = tokenCoding6794_17; + operand.values[18] = tokenCoding6794_18; + operand.values[19] = tokenCoding6794_19; } -Coding x64Parser::tokenCoding6789_16[] = { +Coding x64Parser::tokenCoding6795_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_17[] = { +Coding x64Parser::tokenCoding6795_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_18[] = { +Coding x64Parser::tokenCoding6795_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6789_19[] = { +Coding x64Parser::tokenCoding6795_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6789(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6795(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6789_16; - operand.values[17] = tokenCoding6789_17; - operand.values[18] = tokenCoding6789_18; - operand.values[19] = tokenCoding6789_19; + operand.values[16] = tokenCoding6795_16; + operand.values[17] = tokenCoding6795_17; + operand.values[18] = tokenCoding6795_18; + operand.values[19] = tokenCoding6795_19; } -Coding x64Parser::tokenCoding6790_16[] = { +Coding x64Parser::tokenCoding6796_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_17[] = { +Coding x64Parser::tokenCoding6796_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_18[] = { +Coding x64Parser::tokenCoding6796_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6790_19[] = { +Coding x64Parser::tokenCoding6796_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6790(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6796(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6790_16; - operand.values[17] = tokenCoding6790_17; - operand.values[18] = tokenCoding6790_18; - operand.values[19] = tokenCoding6790_19; -} -x64Token x64Parser::tokenBranches6756[] = { - {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6757 }, - {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6779 }, - {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6781 }, - {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6785, }, - {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6786, }, - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6787, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6788, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6789, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6790, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6791 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6793 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6795 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding6830_16[] = { + operand.values[16] = tokenCoding6796_16; + operand.values[17] = tokenCoding6796_17; + operand.values[18] = tokenCoding6796_18; + operand.values[19] = tokenCoding6796_19; +} +x64Token x64Parser::tokenBranches6762[] = { + {x64Token::TOKEN, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches6763 }, + {x64Token::TOKEN, 13, 0, 0, NULL, NULL, x64Parser::tokenBranches6785 }, + {x64Token::TOKEN, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches6787 }, + {x64Token::NUMBER, 13, 1, 0, NULL,&x64Parser::TokenFunc6791, }, + {x64Token::NUMBER, 15, 1, 0, NULL,&x64Parser::TokenFunc6792, }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6793, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6794, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc6795, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6796, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6797 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6799 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6801 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding6836_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_17[] = { +Coding x64Parser::tokenCoding6836_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_18[] = { +Coding x64Parser::tokenCoding6836_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6830_19[] = { +Coding x64Parser::tokenCoding6836_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6830(x64Operand &operand, int tokenPos) -{ - operand.values[16] = tokenCoding6830_16; - operand.values[17] = tokenCoding6830_17; - operand.values[18] = tokenCoding6830_18; - operand.values[19] = tokenCoding6830_19; -} -x64Token x64Parser::tokenBranches6829[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6830, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc6837(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 551; -} -x64Token x64Parser::tokenBranches6836[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6837, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6836(x64Operand &operand, int tokenPos) { - operand.operandCoding = 553; + operand.values[16] = tokenCoding6836_16; + operand.values[17] = tokenCoding6836_17; + operand.values[18] = tokenCoding6836_18; + operand.values[19] = tokenCoding6836_19; } -x64Token x64Parser::tokenBranches6848[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6835[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6836 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6834[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6835 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc6836, }, {x64Token::EOT } }; void x64Parser::TokenFunc6843(x64Operand &operand, int tokenPos) @@ -27349,52 +27393,29 @@ x64Token x64Parser::tokenBranches6854[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6855, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 556; -} -x64Token x64Parser::tokenBranches6864[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6841[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6842 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6854 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6840[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6841 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6859(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6849(x64Operand &operand, int tokenPos) { - operand.operandCoding = 555; + operand.operandCoding = 553; } -x64Token x64Parser::tokenBranches6858[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6859, }, +x64Token x64Parser::tokenBranches6848[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6849, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6840(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6861(x64Operand &operand, int tokenPos) { - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + operand.operandCoding = 555; } -x64Token x64Parser::tokenBranches6833[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6834 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6840, x64Parser::tokenBranches6840 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6858 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6832[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6833 }, +x64Token x64Parser::tokenBranches6860[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6861, }, {x64Token::EOT } }; void x64Parser::TokenFunc6871(x64Operand &operand, int tokenPos) @@ -27405,21 +27426,44 @@ x64Token x64Parser::tokenBranches6870[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6871, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6847[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6848 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6860 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6846[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6847 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6865(x64Operand &operand, int tokenPos) { - operand.operandCoding = 559; + operand.operandCoding = 556; } -x64Token x64Parser::tokenBranches6882[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, +x64Token x64Parser::tokenBranches6864[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6865, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6869[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6870 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, +void x64Parser::TokenFunc6846(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6839[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6840 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6846, x64Parser::tokenBranches6846 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6864 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6868[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6869 }, +x64Token x64Parser::tokenBranches6838[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6839 }, {x64Token::EOT } }; void x64Parser::TokenFunc6877(x64Operand &operand, int tokenPos) @@ -27438,52 +27482,29 @@ x64Token x64Parser::tokenBranches6888[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6889, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 562; -} -x64Token x64Parser::tokenBranches6898[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6875[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6876 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6888 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6874[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6875 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6893(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6883(x64Operand &operand, int tokenPos) { - operand.operandCoding = 561; + operand.operandCoding = 559; } -x64Token x64Parser::tokenBranches6892[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6893, }, +x64Token x64Parser::tokenBranches6882[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6883, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6874(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6895(x64Operand &operand, int tokenPos) { - operand.values[2] = new Coding[2]; - CleanupValues.push_back(operand.values[2]); - operand.values[2]->type = Coding::reg; - operand.values[2]->val = inputTokens[tokenPos]->val->ival; - operand.values[2]->bits = 0; - operand.values[2]->field = 0; - operand.values[2]->unary = 0; - operand.values[2]->binary = 0; - operand.values[2][1].type = Coding::eot; + operand.operandCoding = 561; } -x64Token x64Parser::tokenBranches6867[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6868 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6874, x64Parser::tokenBranches6874 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6892 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches6866[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6867 }, +x64Token x64Parser::tokenBranches6894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6895, }, {x64Token::EOT } }; void x64Parser::TokenFunc6905(x64Operand &operand, int tokenPos) @@ -27494,21 +27515,44 @@ x64Token x64Parser::tokenBranches6904[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6905, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6881[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6882 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6894 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6880[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6881 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6899(x64Operand &operand, int tokenPos) { - operand.operandCoding = 565; + operand.operandCoding = 562; } -x64Token x64Parser::tokenBranches6916[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, +x64Token x64Parser::tokenBranches6898[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6899, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6903[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6904 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, +void x64Parser::TokenFunc6880(x64Operand &operand, int tokenPos) +{ + operand.values[2] = new Coding[2]; + CleanupValues.push_back(operand.values[2]); + operand.values[2]->type = Coding::reg; + operand.values[2]->val = inputTokens[tokenPos]->val->ival; + operand.values[2]->bits = 0; + operand.values[2]->field = 0; + operand.values[2]->unary = 0; + operand.values[2]->binary = 0; + operand.values[2][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches6873[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6874 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6880, x64Parser::tokenBranches6880 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6898 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6902[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6903 }, +x64Token x64Parser::tokenBranches6872[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6873 }, {x64Token::EOT } }; void x64Parser::TokenFunc6911(x64Operand &operand, int tokenPos) @@ -27527,33 +27571,58 @@ x64Token x64Parser::tokenBranches6922[] = { {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6923, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 568; -} -x64Token x64Parser::tokenBranches6932[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches6909[] = { {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6910 }, {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6922 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches6908[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6909 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6927(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6917(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 565; +} +x64Token x64Parser::tokenBranches6916[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6917, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6929(x64Operand &operand, int tokenPos) { operand.operandCoding = 567; } -x64Token x64Parser::tokenBranches6926[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6927, }, +x64Token x64Parser::tokenBranches6928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6929, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 569; +} +x64Token x64Parser::tokenBranches6938[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6915[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches6916 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6928 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches6914[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6915 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6933(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 568; +} +x64Token x64Parser::tokenBranches6932[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6933, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc6914(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27565,66 +27634,66 @@ void x64Parser::TokenFunc6908(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6901[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6902 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6908, x64Parser::tokenBranches6908 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6926 }, +x64Token x64Parser::tokenBranches6907[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6908 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6914, x64Parser::tokenBranches6914 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6932 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6900[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6901 }, +x64Token x64Parser::tokenBranches6906[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6907 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6939(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) { - operand.operandCoding = 569; + operand.operandCoding = 570; } -x64Token x64Parser::tokenBranches6938[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6939, }, +x64Token x64Parser::tokenBranches6944[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6937[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6938 }, +x64Token x64Parser::tokenBranches6943[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6936[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6937 }, +x64Token x64Parser::tokenBranches6942[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6945(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6951(x64Operand &operand, int tokenPos) { - operand.operandCoding = 570; + operand.operandCoding = 571; } -x64Token x64Parser::tokenBranches6944[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6945, }, +x64Token x64Parser::tokenBranches6950[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6951, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6961(x64Operand &operand, int tokenPos) { - operand.operandCoding = 572; + operand.operandCoding = 573; } -x64Token x64Parser::tokenBranches6954[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, +x64Token x64Parser::tokenBranches6960[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6961, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6943[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6944 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, +x64Token x64Parser::tokenBranches6949[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches6950 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6960 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6942[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6943 }, +x64Token x64Parser::tokenBranches6948[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6949 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6949(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6955(x64Operand &operand, int tokenPos) { - operand.operandCoding = 571; + operand.operandCoding = 572; } -x64Token x64Parser::tokenBranches6948[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6949, }, +x64Token x64Parser::tokenBranches6954[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6955, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6948(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27636,34 +27705,34 @@ void x64Parser::TokenFunc6942(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6935[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6936 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6942, x64Parser::tokenBranches6942 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6948 }, +x64Token x64Parser::tokenBranches6941[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches6942 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6948, x64Parser::tokenBranches6948 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches6954 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6934[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6935 }, +x64Token x64Parser::tokenBranches6940[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6941 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6831[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6832 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6866 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6900 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6934 }, +x64Token x64Parser::tokenBranches6837[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches6838 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches6872 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches6906 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches6940 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6960(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) { - operand.operandCoding = 573; + operand.operandCoding = 574; } -x64Token x64Parser::tokenBranches6959[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6960, }, +x64Token x64Parser::tokenBranches6965[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc6966, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) { - operand.operandCoding = 574; + operand.operandCoding = 575; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27675,13 +27744,13 @@ void x64Parser::TokenFunc6962(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6961[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6962, }, +x64Token x64Parser::tokenBranches6967[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) { - operand.operandCoding = 575; + operand.operandCoding = 576; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27693,13 +27762,13 @@ void x64Parser::TokenFunc6964(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6963[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6964, }, +x64Token x64Parser::tokenBranches6969[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6972(x64Operand &operand, int tokenPos) { - operand.operandCoding = 576; + operand.operandCoding = 577; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27711,13 +27780,13 @@ void x64Parser::TokenFunc6966(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6965[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6966, }, +x64Token x64Parser::tokenBranches6971[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6972, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) { - operand.operandCoding = 576; + operand.operandCoding = 577; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27729,13 +27798,13 @@ void x64Parser::TokenFunc6968(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6967[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6968, }, +x64Token x64Parser::tokenBranches6973[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6974, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) { - operand.operandCoding = 575; + operand.operandCoding = 576; operand.values[11] = new Coding[2]; CleanupValues.push_back(operand.values[11]); operand.values[11]->type = Coding::number; @@ -27747,159 +27816,159 @@ void x64Parser::TokenFunc6970(x64Operand &operand, int tokenPos) operand.values[11][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6969[] = { - {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6970, }, +x64Token x64Parser::tokenBranches6975[] = { + {x64Token::NUMBER, 10, 1, 0, NULL,&x64Parser::TokenFunc6976, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6974_16[] = { +Coding x64Parser::tokenCoding6980_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_17[] = { +Coding x64Parser::tokenCoding6980_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_18[] = { +Coding x64Parser::tokenCoding6980_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6974_19[] = { +Coding x64Parser::tokenCoding6980_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6974(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6980(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6974_16; - operand.values[17] = tokenCoding6974_17; - operand.values[18] = tokenCoding6974_18; - operand.values[19] = tokenCoding6974_19; + operand.values[16] = tokenCoding6980_16; + operand.values[17] = tokenCoding6980_17; + operand.values[18] = tokenCoding6980_18; + operand.values[19] = tokenCoding6980_19; } -x64Token x64Parser::tokenBranches6973[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6974, }, +x64Token x64Parser::tokenBranches6979[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc6980, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6978_16[] = { +Coding x64Parser::tokenCoding6984_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_17[] = { +Coding x64Parser::tokenCoding6984_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_18[] = { +Coding x64Parser::tokenCoding6984_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6978_19[] = { +Coding x64Parser::tokenCoding6984_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6978(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6978_16; - operand.values[17] = tokenCoding6978_17; - operand.values[18] = tokenCoding6978_18; - operand.values[19] = tokenCoding6978_19; + operand.values[16] = tokenCoding6984_16; + operand.values[17] = tokenCoding6984_17; + operand.values[18] = tokenCoding6984_18; + operand.values[19] = tokenCoding6984_19; } -x64Token x64Parser::tokenBranches6977[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6978, }, +x64Token x64Parser::tokenBranches6983[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6976[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6977 }, +x64Token x64Parser::tokenBranches6982[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6981_16[] = { +Coding x64Parser::tokenCoding6987_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_17[] = { +Coding x64Parser::tokenCoding6987_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_18[] = { +Coding x64Parser::tokenCoding6987_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6981_19[] = { +Coding x64Parser::tokenCoding6987_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 35, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6981(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6987(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6981_16; - operand.values[17] = tokenCoding6981_17; - operand.values[18] = tokenCoding6981_18; - operand.values[19] = tokenCoding6981_19; + operand.values[16] = tokenCoding6987_16; + operand.values[17] = tokenCoding6987_17; + operand.values[18] = tokenCoding6987_18; + operand.values[19] = tokenCoding6987_19; } -x64Token x64Parser::tokenBranches6980[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6981, }, +x64Token x64Parser::tokenBranches6986[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6987, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6979[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6980 }, +x64Token x64Parser::tokenBranches6985[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding6984_16[] = { +Coding x64Parser::tokenCoding6990_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_17[] = { +Coding x64Parser::tokenCoding6990_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_18[] = { +Coding x64Parser::tokenCoding6990_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding6984_19[] = { +Coding x64Parser::tokenCoding6990_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 38, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc6984(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding6984_16; - operand.values[17] = tokenCoding6984_17; - operand.values[18] = tokenCoding6984_18; - operand.values[19] = tokenCoding6984_19; + operand.values[16] = tokenCoding6990_16; + operand.values[17] = tokenCoding6990_17; + operand.values[18] = tokenCoding6990_18; + operand.values[19] = tokenCoding6990_19; } -x64Token x64Parser::tokenBranches6983[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6984, }, +x64Token x64Parser::tokenBranches6989[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc6990, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6982[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6983 }, +x64Token x64Parser::tokenBranches6988[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6989 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6990(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6996(x64Operand &operand, int tokenPos) { - operand.operandCoding = 577; + operand.operandCoding = 578; } -x64Token x64Parser::tokenBranches6989[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6990, }, +x64Token x64Parser::tokenBranches6995[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6996, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6998(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) { - operand.operandCoding = 578; + operand.operandCoding = 579; } -x64Token x64Parser::tokenBranches6997[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc6998, }, +x64Token x64Parser::tokenBranches7003[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7012(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) { - operand.operandCoding = 580; + operand.operandCoding = 581; } -x64Token x64Parser::tokenBranches7011[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7012, }, +x64Token x64Parser::tokenBranches7017[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27912,7 +27981,7 @@ void x64Parser::TokenFunc6997(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27925,24 +27994,24 @@ void x64Parser::TokenFunc7011(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6996[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6997, x64Parser::tokenBranches6997 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7011, x64Parser::tokenBranches7011 }, +x64Token x64Parser::tokenBranches7002[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6995[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches6996 }, +x64Token x64Parser::tokenBranches7001[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7002 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7004(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7010(x64Operand &operand, int tokenPos) { - operand.operandCoding = 579; + operand.operandCoding = 580; } -x64Token x64Parser::tokenBranches7003[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7004, }, +x64Token x64Parser::tokenBranches7009[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7010, }, {x64Token::EOT } }; -void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27955,7 +28024,7 @@ void x64Parser::TokenFunc6989(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7001(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -27967,7 +28036,7 @@ void x64Parser::TokenFunc6995(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7009(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -27980,49 +28049,49 @@ void x64Parser::TokenFunc7003(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches6988[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6989, x64Parser::tokenBranches6989 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7003, x64Parser::tokenBranches7003 }, +x64Token x64Parser::tokenBranches6994[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc6995, x64Parser::tokenBranches6995 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7001, x64Parser::tokenBranches7001 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7009, x64Parser::tokenBranches7009 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6987[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6988 }, +x64Token x64Parser::tokenBranches6993[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches6994 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6986[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6987 }, +x64Token x64Parser::tokenBranches6992[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches6993 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches6985[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6986 }, +x64Token x64Parser::tokenBranches6991[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches6992 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7018(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7024(x64Operand &operand, int tokenPos) { - operand.operandCoding = 581; + operand.operandCoding = 582; } -x64Token x64Parser::tokenBranches7017[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7018, }, +x64Token x64Parser::tokenBranches7023[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7024, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7026(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) { - operand.operandCoding = 582; + operand.operandCoding = 583; } -x64Token x64Parser::tokenBranches7025[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7026, }, +x64Token x64Parser::tokenBranches7031[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7040(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) { - operand.operandCoding = 584; + operand.operandCoding = 585; } -x64Token x64Parser::tokenBranches7039[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7040, }, +x64Token x64Parser::tokenBranches7045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28035,7 +28104,7 @@ void x64Parser::TokenFunc7025(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28048,24 +28117,24 @@ void x64Parser::TokenFunc7039(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7024[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7025, x64Parser::tokenBranches7025 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7039, x64Parser::tokenBranches7039 }, +x64Token x64Parser::tokenBranches7030[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7023[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7024 }, +x64Token x64Parser::tokenBranches7029[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7030 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7032(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7038(x64Operand &operand, int tokenPos) { - operand.operandCoding = 583; + operand.operandCoding = 584; } -x64Token x64Parser::tokenBranches7031[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7032, }, +x64Token x64Parser::tokenBranches7037[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7038, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28078,7 +28147,7 @@ void x64Parser::TokenFunc7017(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7029(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -28090,7 +28159,7 @@ void x64Parser::TokenFunc7023(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7037(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28103,49 +28172,49 @@ void x64Parser::TokenFunc7031(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7016[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7017, x64Parser::tokenBranches7017 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7031, x64Parser::tokenBranches7031 }, +x64Token x64Parser::tokenBranches7022[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7023, x64Parser::tokenBranches7023 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7029, x64Parser::tokenBranches7029 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7037, x64Parser::tokenBranches7037 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7015[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7016 }, +x64Token x64Parser::tokenBranches7021[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7022 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7014[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7015 }, +x64Token x64Parser::tokenBranches7020[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7021 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7013[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7014 }, +x64Token x64Parser::tokenBranches7019[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7020 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7046(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7052(x64Operand &operand, int tokenPos) { - operand.operandCoding = 585; + operand.operandCoding = 586; } -x64Token x64Parser::tokenBranches7045[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7046, }, +x64Token x64Parser::tokenBranches7051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7052, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7054(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) { - operand.operandCoding = 586; + operand.operandCoding = 587; } -x64Token x64Parser::tokenBranches7053[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7054, }, +x64Token x64Parser::tokenBranches7059[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7068(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7074(x64Operand &operand, int tokenPos) { - operand.operandCoding = 588; + operand.operandCoding = 589; } -x64Token x64Parser::tokenBranches7067[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7068, }, +x64Token x64Parser::tokenBranches7073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7074, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28158,7 +28227,7 @@ void x64Parser::TokenFunc7053(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28171,24 +28240,24 @@ void x64Parser::TokenFunc7067(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7052[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7053, x64Parser::tokenBranches7053 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7067, x64Parser::tokenBranches7067 }, +x64Token x64Parser::tokenBranches7058[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7051[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7052 }, +x64Token x64Parser::tokenBranches7057[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7058 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7060(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7066(x64Operand &operand, int tokenPos) { - operand.operandCoding = 587; + operand.operandCoding = 588; } -x64Token x64Parser::tokenBranches7059[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7060, }, +x64Token x64Parser::tokenBranches7065[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7066, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28201,7 +28270,7 @@ void x64Parser::TokenFunc7045(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7057(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -28213,7 +28282,7 @@ void x64Parser::TokenFunc7051(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7065(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28226,27 +28295,27 @@ void x64Parser::TokenFunc7059(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7044[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7045, x64Parser::tokenBranches7045 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7059, x64Parser::tokenBranches7059 }, +x64Token x64Parser::tokenBranches7050[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7051, x64Parser::tokenBranches7051 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7057, x64Parser::tokenBranches7057 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7065, x64Parser::tokenBranches7065 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7043[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7044 }, +x64Token x64Parser::tokenBranches7049[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7050 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7042[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7043 }, +x64Token x64Parser::tokenBranches7048[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7049 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7041[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7042 }, +x64Token x64Parser::tokenBranches7047[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7048 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7078(x64Operand &operand, int tokenPos) { - operand.operandCoding = 589; + operand.operandCoding = 590; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28258,45 +28327,45 @@ void x64Parser::TokenFunc7072(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7092_16[] = { +Coding x64Parser::tokenCoding7098_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_17[] = { +Coding x64Parser::tokenCoding7098_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_18[] = { +Coding x64Parser::tokenCoding7098_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7092_19[] = { +Coding x64Parser::tokenCoding7098_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7092(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7098(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7092_16; - operand.values[17] = tokenCoding7092_17; - operand.values[18] = tokenCoding7092_18; - operand.values[19] = tokenCoding7092_19; + operand.values[16] = tokenCoding7098_16; + operand.values[17] = tokenCoding7098_17; + operand.values[18] = tokenCoding7098_18; + operand.values[19] = tokenCoding7098_19; } -x64Token x64Parser::tokenBranches7071[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7072, }, - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7092, }, +x64Token x64Parser::tokenBranches7077[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7078, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7098, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7070[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7071 }, +x64Token x64Parser::tokenBranches7076[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7077 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7069[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7070 }, +x64Token x64Parser::tokenBranches7075[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7076 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7082(x64Operand &operand, int tokenPos) { - operand.operandCoding = 590; + operand.operandCoding = 591; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28308,50 +28377,50 @@ void x64Parser::TokenFunc7076(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7096_16[] = { +Coding x64Parser::tokenCoding7102_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_17[] = { +Coding x64Parser::tokenCoding7102_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_23[] = { +Coding x64Parser::tokenCoding7102_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_18[] = { +Coding x64Parser::tokenCoding7102_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7096_19[] = { +Coding x64Parser::tokenCoding7102_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 138, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7096(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7102(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7096_16; - operand.values[17] = tokenCoding7096_17; - operand.values[23] = tokenCoding7096_23; - operand.values[18] = tokenCoding7096_18; - operand.values[19] = tokenCoding7096_19; + operand.values[16] = tokenCoding7102_16; + operand.values[17] = tokenCoding7102_17; + operand.values[23] = tokenCoding7102_23; + operand.values[18] = tokenCoding7102_18; + operand.values[19] = tokenCoding7102_19; } -x64Token x64Parser::tokenBranches7075[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7076, }, - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7096, }, +x64Token x64Parser::tokenBranches7081[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7082, }, + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc7102, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7074[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7075 }, +x64Token x64Parser::tokenBranches7080[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7081 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7073[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7074 }, +x64Token x64Parser::tokenBranches7079[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7080 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7086(x64Operand &operand, int tokenPos) { - operand.operandCoding = 591; + operand.operandCoding = 592; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28363,46 +28432,46 @@ void x64Parser::TokenFunc7080(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7100_16[] = { +Coding x64Parser::tokenCoding7106_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_17[] = { +Coding x64Parser::tokenCoding7106_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_18[] = { +Coding x64Parser::tokenCoding7106_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7100_19[] = { +Coding x64Parser::tokenCoding7106_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7100(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7106(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7100_16; - operand.values[17] = tokenCoding7100_17; - operand.values[18] = tokenCoding7100_18; - operand.values[19] = tokenCoding7100_19; + operand.values[16] = tokenCoding7106_16; + operand.values[17] = tokenCoding7106_17; + operand.values[18] = tokenCoding7106_18; + operand.values[19] = tokenCoding7106_19; } -x64Token x64Parser::tokenBranches7079[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7080, }, - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7100, }, +x64Token x64Parser::tokenBranches7085[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7086, }, + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7106, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7078[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7079 }, +x64Token x64Parser::tokenBranches7084[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7085 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7077[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7078 }, +x64Token x64Parser::tokenBranches7083[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7084 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7090(x64Operand &operand, int tokenPos) { - operand.operandCoding = 592; + operand.operandCoding = 593; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28414,46 +28483,46 @@ void x64Parser::TokenFunc7084(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7104_16[] = { +Coding x64Parser::tokenCoding7110_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_17[] = { +Coding x64Parser::tokenCoding7110_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_18[] = { +Coding x64Parser::tokenCoding7110_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7104_19[] = { +Coding x64Parser::tokenCoding7110_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7104(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7110(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7104_16; - operand.values[17] = tokenCoding7104_17; - operand.values[18] = tokenCoding7104_18; - operand.values[19] = tokenCoding7104_19; + operand.values[16] = tokenCoding7110_16; + operand.values[17] = tokenCoding7110_17; + operand.values[18] = tokenCoding7110_18; + operand.values[19] = tokenCoding7110_19; } -x64Token x64Parser::tokenBranches7083[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7084, }, - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7104, }, +x64Token x64Parser::tokenBranches7089[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7090, }, + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7110, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7082[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7083 }, +x64Token x64Parser::tokenBranches7088[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7089 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7081[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7082 }, +x64Token x64Parser::tokenBranches7087[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7088 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7094(x64Operand &operand, int tokenPos) { - operand.operandCoding = 593; + operand.operandCoding = 594; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28465,60 +28534,60 @@ void x64Parser::TokenFunc7088(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7108_16[] = { +Coding x64Parser::tokenCoding7114_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_17[] = { +Coding x64Parser::tokenCoding7114_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_18[] = { +Coding x64Parser::tokenCoding7114_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7108_19[] = { +Coding x64Parser::tokenCoding7114_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 139, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7108(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7114(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7108_16; - operand.values[17] = tokenCoding7108_17; - operand.values[18] = tokenCoding7108_18; - operand.values[19] = tokenCoding7108_19; + operand.values[16] = tokenCoding7114_16; + operand.values[17] = tokenCoding7114_17; + operand.values[18] = tokenCoding7114_18; + operand.values[19] = tokenCoding7114_19; } -x64Token x64Parser::tokenBranches7087[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7088, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7108, }, +x64Token x64Parser::tokenBranches7093[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7094, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7114, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7086[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7087 }, +x64Token x64Parser::tokenBranches7092[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7093 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7085[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7086 }, +x64Token x64Parser::tokenBranches7091[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7092 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7113_16[] = { +Coding x64Parser::tokenCoding7119_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_17[] = { +Coding x64Parser::tokenCoding7119_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_18[] = { +Coding x64Parser::tokenCoding7119_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7113_19[] = { +Coding x64Parser::tokenCoding7119_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7119(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -28531,47 +28600,47 @@ void x64Parser::TokenFunc7113(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7113_16; - operand.values[17] = tokenCoding7113_17; - operand.values[18] = tokenCoding7113_18; - operand.values[19] = tokenCoding7113_19; + operand.values[16] = tokenCoding7119_16; + operand.values[17] = tokenCoding7119_17; + operand.values[18] = tokenCoding7119_18; + operand.values[19] = tokenCoding7119_19; } -x64Token x64Parser::tokenBranches7112[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7113, }, +x64Token x64Parser::tokenBranches7118[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7119, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7111[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7112 }, +x64Token x64Parser::tokenBranches7117[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7118 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7110[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7111 }, +x64Token x64Parser::tokenBranches7116[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7117 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7109[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7110 }, +x64Token x64Parser::tokenBranches7115[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7118_16[] = { +Coding x64Parser::tokenCoding7124_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_17[] = { +Coding x64Parser::tokenCoding7124_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_18[] = { +Coding x64Parser::tokenCoding7124_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7118_19[] = { +Coding x64Parser::tokenCoding7124_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7124(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28582,47 +28651,47 @@ void x64Parser::TokenFunc7118(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7118_16; - operand.values[17] = tokenCoding7118_17; - operand.values[18] = tokenCoding7118_18; - operand.values[19] = tokenCoding7118_19; + operand.values[16] = tokenCoding7124_16; + operand.values[17] = tokenCoding7124_17; + operand.values[18] = tokenCoding7124_18; + operand.values[19] = tokenCoding7124_19; } -x64Token x64Parser::tokenBranches7117[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7118, }, +x64Token x64Parser::tokenBranches7123[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7124, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7116[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7117 }, +x64Token x64Parser::tokenBranches7122[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7123 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7115[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7116 }, +x64Token x64Parser::tokenBranches7121[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7122 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7114[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, +x64Token x64Parser::tokenBranches7120[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7123_16[] = { +Coding x64Parser::tokenCoding7129_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_17[] = { +Coding x64Parser::tokenCoding7129_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_18[] = { +Coding x64Parser::tokenCoding7129_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7123_19[] = { +Coding x64Parser::tokenCoding7129_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7129(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28633,47 +28702,47 @@ void x64Parser::TokenFunc7123(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7123_16; - operand.values[17] = tokenCoding7123_17; - operand.values[18] = tokenCoding7123_18; - operand.values[19] = tokenCoding7123_19; + operand.values[16] = tokenCoding7129_16; + operand.values[17] = tokenCoding7129_17; + operand.values[18] = tokenCoding7129_18; + operand.values[19] = tokenCoding7129_19; } -x64Token x64Parser::tokenBranches7122[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7123, }, +x64Token x64Parser::tokenBranches7128[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7129, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7121[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7122 }, +x64Token x64Parser::tokenBranches7127[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7128 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7120[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7121 }, +x64Token x64Parser::tokenBranches7126[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7127 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7119[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, +x64Token x64Parser::tokenBranches7125[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7128_16[] = { +Coding x64Parser::tokenCoding7134_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_17[] = { +Coding x64Parser::tokenCoding7134_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_18[] = { +Coding x64Parser::tokenCoding7134_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7128_19[] = { +Coding x64Parser::tokenCoding7134_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28684,39 +28753,39 @@ void x64Parser::TokenFunc7128(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding7128_16; - operand.values[17] = tokenCoding7128_17; - operand.values[18] = tokenCoding7128_18; - operand.values[19] = tokenCoding7128_19; + operand.values[16] = tokenCoding7134_16; + operand.values[17] = tokenCoding7134_17; + operand.values[18] = tokenCoding7134_18; + operand.values[19] = tokenCoding7134_19; } -x64Token x64Parser::tokenBranches7127[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7128, }, +x64Token x64Parser::tokenBranches7133[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7134, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7126[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7127 }, +x64Token x64Parser::tokenBranches7132[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7133 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7125[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7126 }, +x64Token x64Parser::tokenBranches7131[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7132 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7124[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, +x64Token x64Parser::tokenBranches7130[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7131 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7279_18[] = { +Coding x64Parser::tokenCoding7285_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7279_19[] = { +Coding x64Parser::tokenCoding7285_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7285(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -28727,31 +28796,31 @@ void x64Parser::TokenFunc7279(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7279_18; - operand.values[19] = tokenCoding7279_19; + operand.values[18] = tokenCoding7285_18; + operand.values[19] = tokenCoding7285_19; } -x64Token x64Parser::tokenBranches7278[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7279, }, +x64Token x64Parser::tokenBranches7284[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7285, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7131_16[] = { +Coding x64Parser::tokenCoding7137_16[] = { { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_17[] = { +Coding x64Parser::tokenCoding7137_17[] = { { CODING_NAME("creg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_18[] = { +Coding x64Parser::tokenCoding7137_18[] = { { CODING_NAME("creg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 30, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7131_19[] = { +Coding x64Parser::tokenCoding7137_19[] = { { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("creg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) { operand.values[30] = new Coding[2]; CleanupValues.push_back(operand.values[30]); @@ -28762,29 +28831,29 @@ void x64Parser::TokenFunc7131(x64Operand &operand, int tokenPos) operand.values[30]->unary = 0; operand.values[30]->binary = 0; operand.values[30][1].type = Coding::eot; - operand.values[16] = tokenCoding7131_16; - operand.values[17] = tokenCoding7131_17; - operand.values[18] = tokenCoding7131_18; - operand.values[19] = tokenCoding7131_19; + operand.values[16] = tokenCoding7137_16; + operand.values[17] = tokenCoding7137_17; + operand.values[18] = tokenCoding7137_18; + operand.values[19] = tokenCoding7137_19; } -Coding x64Parser::tokenCoding7134_16[] = { +Coding x64Parser::tokenCoding7140_16[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_17[] = { +Coding x64Parser::tokenCoding7140_17[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_18[] = { +Coding x64Parser::tokenCoding7140_18[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 31, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7134_19[] = { +Coding x64Parser::tokenCoding7140_19[] = { { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("dreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) { operand.values[31] = new Coding[2]; CleanupValues.push_back(operand.values[31]); @@ -28795,29 +28864,29 @@ void x64Parser::TokenFunc7134(x64Operand &operand, int tokenPos) operand.values[31]->unary = 0; operand.values[31]->binary = 0; operand.values[31][1].type = Coding::eot; - operand.values[16] = tokenCoding7134_16; - operand.values[17] = tokenCoding7134_17; - operand.values[18] = tokenCoding7134_18; - operand.values[19] = tokenCoding7134_19; + operand.values[16] = tokenCoding7140_16; + operand.values[17] = tokenCoding7140_17; + operand.values[18] = tokenCoding7140_18; + operand.values[19] = tokenCoding7140_19; } -Coding x64Parser::tokenCoding7137_16[] = { +Coding x64Parser::tokenCoding7143_16[] = { { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_17[] = { +Coding x64Parser::tokenCoding7143_17[] = { { CODING_NAME("treg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_18[] = { +Coding x64Parser::tokenCoding7143_18[] = { { CODING_NAME("treg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 32, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7137_19[] = { +Coding x64Parser::tokenCoding7143_19[] = { { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("treg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 36, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) { operand.values[32] = new Coding[2]; CleanupValues.push_back(operand.values[32]); @@ -28828,28 +28897,28 @@ void x64Parser::TokenFunc7137(x64Operand &operand, int tokenPos) operand.values[32]->unary = 0; operand.values[32]->binary = 0; operand.values[32][1].type = Coding::eot; - operand.values[16] = tokenCoding7137_16; - operand.values[17] = tokenCoding7137_17; - operand.values[18] = tokenCoding7137_18; - operand.values[19] = tokenCoding7137_19; + operand.values[16] = tokenCoding7143_16; + operand.values[17] = tokenCoding7143_17; + operand.values[18] = tokenCoding7143_18; + operand.values[19] = tokenCoding7143_19; } -Coding x64Parser::tokenCoding7264_16[] = { +Coding x64Parser::tokenCoding7270_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_17[] = { +Coding x64Parser::tokenCoding7270_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_18[] = { +Coding x64Parser::tokenCoding7270_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7264_19[] = { +Coding x64Parser::tokenCoding7270_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7270(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -28860,72 +28929,72 @@ void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7264_16; - operand.values[17] = tokenCoding7264_17; - operand.values[18] = tokenCoding7264_18; - operand.values[19] = tokenCoding7264_19; + operand.values[16] = tokenCoding7270_16; + operand.values[17] = tokenCoding7270_17; + operand.values[18] = tokenCoding7270_18; + operand.values[19] = tokenCoding7270_19; } -x64Token x64Parser::tokenBranches7130[] = { - {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7131, }, - {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7134, }, - {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7137, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7278 }, +x64Token x64Parser::tokenBranches7136[] = { + {x64Token::REGISTERCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7137, }, + {x64Token::REGISTERCLASS, 22, 1, 0, NULL,&x64Parser::TokenFunc7140, }, + {x64Token::REGISTERCLASS, 23, 1, 0, NULL,&x64Parser::TokenFunc7143, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7270, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7129[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, +x64Token x64Parser::tokenBranches7135[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7136 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7143(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7149(x64Operand &operand, int tokenPos) { - operand.operandCoding = 594; + operand.operandCoding = 595; } -x64Token x64Parser::tokenBranches7142[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7143, }, +x64Token x64Parser::tokenBranches7148[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7149, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7141[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7142 }, +x64Token x64Parser::tokenBranches7147[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7148 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7140[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7141 }, +x64Token x64Parser::tokenBranches7146[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7151(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) { - operand.operandCoding = 595; + operand.operandCoding = 596; } -x64Token x64Parser::tokenBranches7150[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7151, }, +x64Token x64Parser::tokenBranches7156[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7149[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7150 }, +x64Token x64Parser::tokenBranches7155[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7148[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7149 }, +x64Token x64Parser::tokenBranches7154[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7165(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) { - operand.operandCoding = 597; + operand.operandCoding = 598; } -x64Token x64Parser::tokenBranches7164[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7165, }, +x64Token x64Parser::tokenBranches7170[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7171, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7163[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7164 }, +x64Token x64Parser::tokenBranches7169[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7162[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7163 }, +x64Token x64Parser::tokenBranches7168[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28938,7 +29007,7 @@ void x64Parser::TokenFunc7148(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28951,32 +29020,32 @@ void x64Parser::TokenFunc7162(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7147[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7148, x64Parser::tokenBranches7148 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7162, x64Parser::tokenBranches7162 }, +x64Token x64Parser::tokenBranches7153[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7146[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7147 }, +x64Token x64Parser::tokenBranches7152[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7153 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7157(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7163(x64Operand &operand, int tokenPos) { - operand.operandCoding = 596; + operand.operandCoding = 597; } -x64Token x64Parser::tokenBranches7156[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7157, }, +x64Token x64Parser::tokenBranches7162[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7163, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7155[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7156 }, +x64Token x64Parser::tokenBranches7161[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7162 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7154[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7155 }, +x64Token x64Parser::tokenBranches7160[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7161 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -28989,7 +29058,7 @@ void x64Parser::TokenFunc7140(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7152(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29001,7 +29070,7 @@ void x64Parser::TokenFunc7146(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7160(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29014,29 +29083,29 @@ void x64Parser::TokenFunc7154(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7139[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7140, x64Parser::tokenBranches7140 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7154, x64Parser::tokenBranches7154 }, +x64Token x64Parser::tokenBranches7145[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7146, x64Parser::tokenBranches7146 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7152, x64Parser::tokenBranches7152 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7160, x64Parser::tokenBranches7160 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7225_16[] = { +Coding x64Parser::tokenCoding7231_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_17[] = { +Coding x64Parser::tokenCoding7231_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_18[] = { +Coding x64Parser::tokenCoding7231_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7225_19[] = { +Coding x64Parser::tokenCoding7231_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7231(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29047,32 +29116,32 @@ void x64Parser::TokenFunc7225(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7225_16; - operand.values[17] = tokenCoding7225_17; - operand.values[18] = tokenCoding7225_18; - operand.values[19] = tokenCoding7225_19; + operand.values[16] = tokenCoding7231_16; + operand.values[17] = tokenCoding7231_17; + operand.values[18] = tokenCoding7231_18; + operand.values[19] = tokenCoding7231_19; } -Coding x64Parser::tokenCoding7229_16[] = { +Coding x64Parser::tokenCoding7235_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_17[] = { +Coding x64Parser::tokenCoding7235_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_23[] = { +Coding x64Parser::tokenCoding7235_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_18[] = { +Coding x64Parser::tokenCoding7235_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7229_19[] = { +Coding x64Parser::tokenCoding7235_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 136, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7235(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29083,75 +29152,75 @@ void x64Parser::TokenFunc7229(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7229_16; - operand.values[17] = tokenCoding7229_17; - operand.values[23] = tokenCoding7229_23; - operand.values[18] = tokenCoding7229_18; - operand.values[19] = tokenCoding7229_19; + operand.values[16] = tokenCoding7235_16; + operand.values[17] = tokenCoding7235_17; + operand.values[23] = tokenCoding7235_23; + operand.values[18] = tokenCoding7235_18; + operand.values[19] = tokenCoding7235_19; } -x64Token x64Parser::tokenBranches7224[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7225, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7229, }, +x64Token x64Parser::tokenBranches7230[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7231, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc7235, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7223[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7224 }, +x64Token x64Parser::tokenBranches7229[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7230 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7138[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7139 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7223 }, +x64Token x64Parser::tokenBranches7144[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7145 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7229 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7171(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7177(x64Operand &operand, int tokenPos) { - operand.operandCoding = 598; + operand.operandCoding = 599; } -x64Token x64Parser::tokenBranches7170[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7171, }, +x64Token x64Parser::tokenBranches7176[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7177, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7169[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7170 }, +x64Token x64Parser::tokenBranches7175[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7176 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7168[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7169 }, +x64Token x64Parser::tokenBranches7174[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7179(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) { - operand.operandCoding = 599; + operand.operandCoding = 600; } -x64Token x64Parser::tokenBranches7178[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7179, }, +x64Token x64Parser::tokenBranches7184[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7177[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7178 }, +x64Token x64Parser::tokenBranches7183[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7176[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7177 }, +x64Token x64Parser::tokenBranches7182[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7193(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) { - operand.operandCoding = 601; + operand.operandCoding = 602; } -x64Token x64Parser::tokenBranches7192[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7193, }, +x64Token x64Parser::tokenBranches7198[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7199, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7191[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7192 }, +x64Token x64Parser::tokenBranches7197[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7190[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7191 }, +x64Token x64Parser::tokenBranches7196[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29164,7 +29233,7 @@ void x64Parser::TokenFunc7176(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29177,32 +29246,32 @@ void x64Parser::TokenFunc7190(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7175[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7176, x64Parser::tokenBranches7176 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7190, x64Parser::tokenBranches7190 }, +x64Token x64Parser::tokenBranches7181[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7174[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7175 }, +x64Token x64Parser::tokenBranches7180[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7181 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7185(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7191(x64Operand &operand, int tokenPos) { - operand.operandCoding = 600; + operand.operandCoding = 601; } -x64Token x64Parser::tokenBranches7184[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7185, }, +x64Token x64Parser::tokenBranches7190[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7191, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7183[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7184 }, +x64Token x64Parser::tokenBranches7189[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7190 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7182[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7183 }, +x64Token x64Parser::tokenBranches7188[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7189 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29215,7 +29284,7 @@ void x64Parser::TokenFunc7168(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7180(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29227,7 +29296,7 @@ void x64Parser::TokenFunc7174(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7188(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29240,30 +29309,30 @@ void x64Parser::TokenFunc7182(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7167[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7168, x64Parser::tokenBranches7168 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7182, x64Parser::tokenBranches7182 }, +x64Token x64Parser::tokenBranches7173[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7174, x64Parser::tokenBranches7174 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7180, x64Parser::tokenBranches7180 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7188, x64Parser::tokenBranches7188 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7233_16[] = { +Coding x64Parser::tokenCoding7239_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_17[] = { +Coding x64Parser::tokenCoding7239_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_18[] = { +Coding x64Parser::tokenCoding7239_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7233_19[] = { +Coding x64Parser::tokenCoding7239_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7239(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29274,28 +29343,28 @@ void x64Parser::TokenFunc7233(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7233_16; - operand.values[17] = tokenCoding7233_17; - operand.values[18] = tokenCoding7233_18; - operand.values[19] = tokenCoding7233_19; + operand.values[16] = tokenCoding7239_16; + operand.values[17] = tokenCoding7239_17; + operand.values[18] = tokenCoding7239_18; + operand.values[19] = tokenCoding7239_19; } -Coding x64Parser::tokenCoding7258_16[] = { +Coding x64Parser::tokenCoding7264_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_17[] = { +Coding x64Parser::tokenCoding7264_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_18[] = { +Coding x64Parser::tokenCoding7264_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7258_19[] = { +Coding x64Parser::tokenCoding7264_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7264(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29306,106 +29375,39 @@ void x64Parser::TokenFunc7258(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7258_16; - operand.values[17] = tokenCoding7258_17; - operand.values[18] = tokenCoding7258_18; - operand.values[19] = tokenCoding7258_19; -} -x64Token x64Parser::tokenBranches7232[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7233, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7258, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7231[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7232 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7166[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7167 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7231 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7199(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 602; + operand.values[16] = tokenCoding7264_16; + operand.values[17] = tokenCoding7264_17; + operand.values[18] = tokenCoding7264_18; + operand.values[19] = tokenCoding7264_19; } -x64Token x64Parser::tokenBranches7198[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7199, }, +x64Token x64Parser::tokenBranches7238[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7239, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7264, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7197[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7198 }, +x64Token x64Parser::tokenBranches7237[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7238 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7196[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7197 }, +x64Token x64Parser::tokenBranches7172[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7173 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7237 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7207(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7205(x64Operand &operand, int tokenPos) { operand.operandCoding = 603; } -x64Token x64Parser::tokenBranches7206[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7207, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7205[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7206 }, - {x64Token::EOT } -}; x64Token x64Parser::tokenBranches7204[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7205 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7221(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 605; -} -x64Token x64Parser::tokenBranches7220[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7221, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7219[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7220 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches7218[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7219 }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7205, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7204(x64Operand &operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} -void x64Parser::TokenFunc7218(x64Operand &operand, int tokenPos) -{ - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); -} x64Token x64Parser::tokenBranches7203[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7204, x64Parser::tokenBranches7204 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7218, x64Parser::tokenBranches7218 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7204 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches7202[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7203 }, {x64Token::EOT } }; void x64Parser::TokenFunc7213(x64Operand &operand, int tokenPos) @@ -29424,7 +29426,23 @@ x64Token x64Parser::tokenBranches7210[] = { {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7211 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7227(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 606; +} +x64Token x64Parser::tokenBranches7226[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7227, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7226 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7224[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7225 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29437,7 +29455,58 @@ void x64Parser::TokenFunc7196(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } +void x64Parser::TokenFunc7224(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +x64Token x64Parser::tokenBranches7209[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7224, x64Parser::tokenBranches7224 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7208[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7209 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7219(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 605; +} +x64Token x64Parser::tokenBranches7218[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7219, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7217[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7218 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches7216[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7217 }, + {x64Token::EOT } +}; void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) +{ + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); +} +void x64Parser::TokenFunc7208(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -29449,7 +29518,7 @@ void x64Parser::TokenFunc7202(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7216(x64Operand &operand, int tokenPos) { operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); @@ -29462,30 +29531,30 @@ void x64Parser::TokenFunc7210(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7195[] = { - {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7196, x64Parser::tokenBranches7196 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, - {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7210, x64Parser::tokenBranches7210 }, +x64Token x64Parser::tokenBranches7201[] = { + {x64Token::NUMBER, 6, 0, 0, NULL,&x64Parser::TokenFunc7202, x64Parser::tokenBranches7202 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7208, x64Parser::tokenBranches7208 }, + {x64Token::NUMBER, 7, 0, 0, NULL,&x64Parser::TokenFunc7216, x64Parser::tokenBranches7216 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7237_16[] = { +Coding x64Parser::tokenCoding7243_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_17[] = { +Coding x64Parser::tokenCoding7243_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_18[] = { +Coding x64Parser::tokenCoding7243_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7237_19[] = { +Coding x64Parser::tokenCoding7243_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7243(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29496,42 +29565,42 @@ void x64Parser::TokenFunc7237(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7237_16; - operand.values[17] = tokenCoding7237_17; - operand.values[18] = tokenCoding7237_18; - operand.values[19] = tokenCoding7237_19; + operand.values[16] = tokenCoding7243_16; + operand.values[17] = tokenCoding7243_17; + operand.values[18] = tokenCoding7243_18; + operand.values[19] = tokenCoding7243_19; } -x64Token x64Parser::tokenBranches7236[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7237, }, +x64Token x64Parser::tokenBranches7242[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7243, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7235[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7236 }, +x64Token x64Parser::tokenBranches7241[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7242 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7194[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7195 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7235 }, +x64Token x64Parser::tokenBranches7200[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7201 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7241 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7241_16[] = { +Coding x64Parser::tokenCoding7247_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_17[] = { +Coding x64Parser::tokenCoding7247_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_18[] = { +Coding x64Parser::tokenCoding7247_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7241_19[] = { +Coding x64Parser::tokenCoding7247_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 137, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7247(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29542,142 +29611,142 @@ void x64Parser::TokenFunc7241(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7241_16; - operand.values[17] = tokenCoding7241_17; - operand.values[18] = tokenCoding7241_18; - operand.values[19] = tokenCoding7241_19; + operand.values[16] = tokenCoding7247_16; + operand.values[17] = tokenCoding7247_17; + operand.values[18] = tokenCoding7247_18; + operand.values[19] = tokenCoding7247_19; } -x64Token x64Parser::tokenBranches7240[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7241, }, +x64Token x64Parser::tokenBranches7246[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7247, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7239[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7240 }, +x64Token x64Parser::tokenBranches7245[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7246 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7238[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7239 }, +x64Token x64Parser::tokenBranches7244[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7245 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7245_16[] = { +Coding x64Parser::tokenCoding7251_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_17[] = { +Coding x64Parser::tokenCoding7251_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_18[] = { +Coding x64Parser::tokenCoding7251_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7245_19[] = { +Coding x64Parser::tokenCoding7251_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7245(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7245_16; - operand.values[17] = tokenCoding7245_17; - operand.values[18] = tokenCoding7245_18; - operand.values[19] = tokenCoding7245_19; + operand.values[16] = tokenCoding7251_16; + operand.values[17] = tokenCoding7251_17; + operand.values[18] = tokenCoding7251_18; + operand.values[19] = tokenCoding7251_19; } -x64Token x64Parser::tokenBranches7244[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7245, }, +x64Token x64Parser::tokenBranches7250[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7251, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7248_16[] = { +Coding x64Parser::tokenCoding7254_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_17[] = { +Coding x64Parser::tokenCoding7254_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_18[] = { +Coding x64Parser::tokenCoding7254_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7248_19[] = { +Coding x64Parser::tokenCoding7254_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7248_16; - operand.values[17] = tokenCoding7248_17; - operand.values[18] = tokenCoding7248_18; - operand.values[19] = tokenCoding7248_19; + operand.values[16] = tokenCoding7254_16; + operand.values[17] = tokenCoding7254_17; + operand.values[18] = tokenCoding7254_18; + operand.values[19] = tokenCoding7254_19; } -Coding x64Parser::tokenCoding7251_16[] = { +Coding x64Parser::tokenCoding7257_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_17[] = { +Coding x64Parser::tokenCoding7257_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_18[] = { +Coding x64Parser::tokenCoding7257_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7251_19[] = { +Coding x64Parser::tokenCoding7257_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7251(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7257(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7251_16; - operand.values[17] = tokenCoding7251_17; - operand.values[18] = tokenCoding7251_18; - operand.values[19] = tokenCoding7251_19; + operand.values[16] = tokenCoding7257_16; + operand.values[17] = tokenCoding7257_17; + operand.values[18] = tokenCoding7257_18; + operand.values[19] = tokenCoding7257_19; } -Coding x64Parser::tokenCoding7254_16[] = { +Coding x64Parser::tokenCoding7260_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_17[] = { +Coding x64Parser::tokenCoding7260_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_18[] = { +Coding x64Parser::tokenCoding7260_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7254_19[] = { +Coding x64Parser::tokenCoding7260_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 142, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7254(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7260(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7254_16; - operand.values[17] = tokenCoding7254_17; - operand.values[18] = tokenCoding7254_18; - operand.values[19] = tokenCoding7254_19; + operand.values[16] = tokenCoding7260_16; + operand.values[17] = tokenCoding7260_17; + operand.values[18] = tokenCoding7260_18; + operand.values[19] = tokenCoding7260_19; } -x64Token x64Parser::tokenBranches7243[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7248, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7251, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7254, }, +x64Token x64Parser::tokenBranches7249[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7250 }, + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7254, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7257, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc7260, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7242[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7243 }, +x64Token x64Parser::tokenBranches7248[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7249 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7275_18[] = { +Coding x64Parser::tokenCoding7281_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7275_19[] = { +Coding x64Parser::tokenCoding7281_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7281(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -29688,31 +29757,31 @@ void x64Parser::TokenFunc7275(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7275_18; - operand.values[19] = tokenCoding7275_19; + operand.values[18] = tokenCoding7281_18; + operand.values[19] = tokenCoding7281_19; } -x64Token x64Parser::tokenBranches7274[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7275, }, +x64Token x64Parser::tokenBranches7280[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7281, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7261_16[] = { +Coding x64Parser::tokenCoding7267_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_17[] = { +Coding x64Parser::tokenCoding7267_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_18[] = { +Coding x64Parser::tokenCoding7267_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7261_19[] = { +Coding x64Parser::tokenCoding7267_19[] = { { CODING_NAME("segm") Coding::stateFunc, 4 }, { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29723,32 +29792,32 @@ void x64Parser::TokenFunc7261(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7261_16; - operand.values[17] = tokenCoding7261_17; - operand.values[18] = tokenCoding7261_18; - operand.values[19] = tokenCoding7261_19; + operand.values[16] = tokenCoding7267_16; + operand.values[17] = tokenCoding7267_17; + operand.values[18] = tokenCoding7267_18; + operand.values[19] = tokenCoding7267_19; } -x64Token x64Parser::tokenBranches7260[] = { - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7261, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7274 }, +x64Token x64Parser::tokenBranches7266[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7259[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7260 }, +x64Token x64Parser::tokenBranches7265[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7283_18[] = { +Coding x64Parser::tokenCoding7289_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7283_19[] = { +Coding x64Parser::tokenCoding7289_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 199, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7289(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -29759,30 +29828,30 @@ void x64Parser::TokenFunc7283(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7283_18; - operand.values[19] = tokenCoding7283_19; + operand.values[18] = tokenCoding7289_18; + operand.values[19] = tokenCoding7289_19; } -x64Token x64Parser::tokenBranches7282[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7283, }, +x64Token x64Parser::tokenBranches7288[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7289, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7267_16[] = { +Coding x64Parser::tokenCoding7273_16[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_17[] = { +Coding x64Parser::tokenCoding7273_17[] = { { CODING_NAME("segm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_18[] = { +Coding x64Parser::tokenCoding7273_18[] = { { CODING_NAME("segm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 33, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7267_19[] = { +Coding x64Parser::tokenCoding7273_19[] = { { CODING_NAME("segm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 140, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7273(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29793,29 +29862,29 @@ void x64Parser::TokenFunc7267(x64Operand &operand, int tokenPos) operand.values[33]->unary = 0; operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; - operand.values[16] = tokenCoding7267_16; - operand.values[17] = tokenCoding7267_17; - operand.values[18] = tokenCoding7267_18; - operand.values[19] = tokenCoding7267_19; + operand.values[16] = tokenCoding7273_16; + operand.values[17] = tokenCoding7273_17; + operand.values[18] = tokenCoding7273_18; + operand.values[19] = tokenCoding7273_19; } -x64Token x64Parser::tokenBranches7266[] = { - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7267, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7282 }, +x64Token x64Parser::tokenBranches7272[] = { + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7273, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7288 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7265[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7266 }, +x64Token x64Parser::tokenBranches7271[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7272 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7271_18[] = { +Coding x64Parser::tokenCoding7277_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7271_19[] = { +Coding x64Parser::tokenCoding7277_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7277(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -29828,22 +29897,22 @@ void x64Parser::TokenFunc7271(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[18] = tokenCoding7271_18; - operand.values[19] = tokenCoding7271_19; + operand.values[18] = tokenCoding7277_18; + operand.values[19] = tokenCoding7277_19; } -x64Token x64Parser::tokenBranches7270[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7271, }, +x64Token x64Parser::tokenBranches7276[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc7277, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7269[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7270 }, +x64Token x64Parser::tokenBranches7275[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7276 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7268[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7269 }, +x64Token x64Parser::tokenBranches7274[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7275 }, {x64Token::EOT } }; -void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) { operand.values[30] = new Coding[2]; CleanupValues.push_back(operand.values[30]); @@ -29855,7 +29924,7 @@ void x64Parser::TokenFunc6976(x64Operand &operand, int tokenPos) operand.values[30]->binary = 0; operand.values[30][1].type = Coding::eot; } -void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6985(x64Operand &operand, int tokenPos) { operand.values[31] = new Coding[2]; CleanupValues.push_back(operand.values[31]); @@ -29867,7 +29936,7 @@ void x64Parser::TokenFunc6979(x64Operand &operand, int tokenPos) operand.values[31]->binary = 0; operand.values[31][1].type = Coding::eot; } -void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc6988(x64Operand &operand, int tokenPos) { operand.values[32] = new Coding[2]; CleanupValues.push_back(operand.values[32]); @@ -29879,7 +29948,7 @@ void x64Parser::TokenFunc6982(x64Operand &operand, int tokenPos) operand.values[32]->binary = 0; operand.values[32][1].type = Coding::eot; } -void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7075(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29891,7 +29960,7 @@ void x64Parser::TokenFunc7069(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7079(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29903,7 +29972,7 @@ void x64Parser::TokenFunc7073(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7083(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29915,7 +29984,7 @@ void x64Parser::TokenFunc7077(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7087(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29927,7 +29996,7 @@ void x64Parser::TokenFunc7081(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7091(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -29939,7 +30008,7 @@ void x64Parser::TokenFunc7085(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7248(x64Operand &operand, int tokenPos) { operand.values[33] = new Coding[2]; CleanupValues.push_back(operand.values[33]); @@ -29951,66 +30020,66 @@ void x64Parser::TokenFunc7242(x64Operand &operand, int tokenPos) operand.values[33]->binary = 0; operand.values[33][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches6975[] = { - {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6976, x64Parser::tokenBranches6976 }, - {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6979, x64Parser::tokenBranches6979 }, - {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6985 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7013 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7041 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7069, x64Parser::tokenBranches7069 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7073, x64Parser::tokenBranches7073 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7077, x64Parser::tokenBranches7077 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7081, x64Parser::tokenBranches7081 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7085, x64Parser::tokenBranches7085 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7109 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7114 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7119 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7124 }, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7129 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7138 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7166 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7194 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7238 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7242, x64Parser::tokenBranches7242 }, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7259 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7268 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7297(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches6981[] = { + {x64Token::REGISTERCLASS, 21, 0, 0, NULL,&x64Parser::TokenFunc6982, x64Parser::tokenBranches6982 }, + {x64Token::REGISTERCLASS, 22, 0, 0, NULL,&x64Parser::TokenFunc6985, x64Parser::tokenBranches6985 }, + {x64Token::REGISTERCLASS, 23, 0, 0, NULL,&x64Parser::TokenFunc6988, x64Parser::tokenBranches6988 }, + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches6991 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7019 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7047 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc7075, x64Parser::tokenBranches7075 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc7079, x64Parser::tokenBranches7079 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7083, x64Parser::tokenBranches7083 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7087, x64Parser::tokenBranches7087 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7091, x64Parser::tokenBranches7091 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7115 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7120 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7125 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7130 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches7135 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7144 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7172 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7200 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7244 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7248, x64Parser::tokenBranches7248 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches7265 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches7271 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches7274 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7303(x64Operand &operand, int tokenPos) { - operand.operandCoding = 606; + operand.operandCoding = 607; } -x64Token x64Parser::tokenBranches7296[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7297, }, +x64Token x64Parser::tokenBranches7302[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7303, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7295[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, +x64Token x64Parser::tokenBranches7301[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7302 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7294[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, +x64Token x64Parser::tokenBranches7300[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7301 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7310(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7316(x64Operand &operand, int tokenPos) { - operand.operandCoding = 607; + operand.operandCoding = 608; } -x64Token x64Parser::tokenBranches7309[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7310, }, +x64Token x64Parser::tokenBranches7315[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7316, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7308[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7309 }, +x64Token x64Parser::tokenBranches7314[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7307[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7308 }, +x64Token x64Parser::tokenBranches7313[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7314 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7313(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30022,60 +30091,60 @@ void x64Parser::TokenFunc7307(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7293[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7307, x64Parser::tokenBranches7307 }, +x64Token x64Parser::tokenBranches7299[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7300 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7313, x64Parser::tokenBranches7313 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7292[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, +x64Token x64Parser::tokenBranches7298[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7299 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7291[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, +x64Token x64Parser::tokenBranches7297[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7298 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7290[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, +x64Token x64Parser::tokenBranches7296[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7297 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7289[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7290 }, +x64Token x64Parser::tokenBranches7295[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7296 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7323(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7329(x64Operand &operand, int tokenPos) { - operand.operandCoding = 608; + operand.operandCoding = 609; } -x64Token x64Parser::tokenBranches7322[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7323, }, +x64Token x64Parser::tokenBranches7328[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7329, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7321[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, +x64Token x64Parser::tokenBranches7327[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7328 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7320[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, +x64Token x64Parser::tokenBranches7326[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7327 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7336(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7342(x64Operand &operand, int tokenPos) { - operand.operandCoding = 609; + operand.operandCoding = 610; } -x64Token x64Parser::tokenBranches7335[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7336, }, +x64Token x64Parser::tokenBranches7341[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7342, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7334[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7335 }, +x64Token x64Parser::tokenBranches7340[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7333[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7334 }, +x64Token x64Parser::tokenBranches7339[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7339(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30087,65 +30156,65 @@ void x64Parser::TokenFunc7333(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7319[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7320 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7333, x64Parser::tokenBranches7333 }, +x64Token x64Parser::tokenBranches7325[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7326 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7339, x64Parser::tokenBranches7339 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7318[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7319 }, +x64Token x64Parser::tokenBranches7324[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7325 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7317[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7318 }, +x64Token x64Parser::tokenBranches7323[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7324 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7316[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7317 }, +x64Token x64Parser::tokenBranches7322[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7323 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7315[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7316 }, +x64Token x64Parser::tokenBranches7321[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7322 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7288[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7289 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7315 }, +x64Token x64Parser::tokenBranches7294[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7295 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7321 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7287[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7288 }, +x64Token x64Parser::tokenBranches7293[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7294 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7286[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7287 }, +x64Token x64Parser::tokenBranches7292[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7293 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7345(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7351(x64Operand &operand, int tokenPos) { - operand.operandCoding = 610; + operand.operandCoding = 611; } -x64Token x64Parser::tokenBranches7344[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7345, }, +x64Token x64Parser::tokenBranches7350[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7351, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7356(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7362(x64Operand &operand, int tokenPos) { - operand.operandCoding = 611; + operand.operandCoding = 612; } -x64Token x64Parser::tokenBranches7355[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7356, }, +x64Token x64Parser::tokenBranches7361[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7362, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7354[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7355 }, +x64Token x64Parser::tokenBranches7360[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7353[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7354 }, +x64Token x64Parser::tokenBranches7359[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7359(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30157,69 +30226,69 @@ void x64Parser::TokenFunc7353(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7343[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7353, x64Parser::tokenBranches7353 }, +x64Token x64Parser::tokenBranches7349[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7350 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7359, x64Parser::tokenBranches7359 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7342[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7343 }, +x64Token x64Parser::tokenBranches7348[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7349 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7341[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7342 }, +x64Token x64Parser::tokenBranches7347[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7348 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7340[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7341 }, +x64Token x64Parser::tokenBranches7346[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7347 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7339[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7340 }, +x64Token x64Parser::tokenBranches7345[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7346 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7338[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7339 }, +x64Token x64Parser::tokenBranches7344[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7345 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7285[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7286 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7338 }, +x64Token x64Parser::tokenBranches7291[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7292 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7344 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7369(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7375(x64Operand &operand, int tokenPos) { - operand.operandCoding = 612; + operand.operandCoding = 613; } -x64Token x64Parser::tokenBranches7368[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7369, }, +x64Token x64Parser::tokenBranches7374[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7375, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7367[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, +x64Token x64Parser::tokenBranches7373[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7374 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7366[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, +x64Token x64Parser::tokenBranches7372[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7373 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7382(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7388(x64Operand &operand, int tokenPos) { - operand.operandCoding = 613; + operand.operandCoding = 614; } -x64Token x64Parser::tokenBranches7381[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7382, }, +x64Token x64Parser::tokenBranches7387[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7388, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7380[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7381 }, +x64Token x64Parser::tokenBranches7386[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7379[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7380 }, +x64Token x64Parser::tokenBranches7385[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7386 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7385(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30231,60 +30300,60 @@ void x64Parser::TokenFunc7379(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7365[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7379, x64Parser::tokenBranches7379 }, +x64Token x64Parser::tokenBranches7371[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7372 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7385, x64Parser::tokenBranches7385 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7364[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, +x64Token x64Parser::tokenBranches7370[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7371 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7363[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, +x64Token x64Parser::tokenBranches7369[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7370 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7362[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, +x64Token x64Parser::tokenBranches7368[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7369 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7361[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7362 }, +x64Token x64Parser::tokenBranches7367[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7368 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7395(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7401(x64Operand &operand, int tokenPos) { - operand.operandCoding = 614; + operand.operandCoding = 615; } -x64Token x64Parser::tokenBranches7394[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7395, }, +x64Token x64Parser::tokenBranches7400[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7401, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7393[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, +x64Token x64Parser::tokenBranches7399[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7400 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7392[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, +x64Token x64Parser::tokenBranches7398[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7399 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7408(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7414(x64Operand &operand, int tokenPos) { - operand.operandCoding = 615; + operand.operandCoding = 616; } -x64Token x64Parser::tokenBranches7407[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7408, }, +x64Token x64Parser::tokenBranches7413[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7414, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7406[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7407 }, +x64Token x64Parser::tokenBranches7412[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7405[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7406 }, +x64Token x64Parser::tokenBranches7411[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7411(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30296,65 +30365,65 @@ void x64Parser::TokenFunc7405(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7391[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7392 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7405, x64Parser::tokenBranches7405 }, +x64Token x64Parser::tokenBranches7397[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7398 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7411, x64Parser::tokenBranches7411 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7390[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7391 }, +x64Token x64Parser::tokenBranches7396[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7397 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7389[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7390 }, +x64Token x64Parser::tokenBranches7395[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7396 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7388[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7389 }, +x64Token x64Parser::tokenBranches7394[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7395 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7387[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7388 }, +x64Token x64Parser::tokenBranches7393[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7394 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7360[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7361 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7387 }, +x64Token x64Parser::tokenBranches7366[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7367 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7393 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7359[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7360 }, +x64Token x64Parser::tokenBranches7365[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7366 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7358[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7359 }, +x64Token x64Parser::tokenBranches7364[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7365 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7417(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7423(x64Operand &operand, int tokenPos) { - operand.operandCoding = 616; + operand.operandCoding = 617; } -x64Token x64Parser::tokenBranches7416[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7417, }, +x64Token x64Parser::tokenBranches7422[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7423, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7428(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7434(x64Operand &operand, int tokenPos) { - operand.operandCoding = 617; + operand.operandCoding = 618; } -x64Token x64Parser::tokenBranches7427[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7428, }, +x64Token x64Parser::tokenBranches7433[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7434, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7426[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7427 }, +x64Token x64Parser::tokenBranches7432[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7425[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7426 }, +x64Token x64Parser::tokenBranches7431[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7431(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30366,69 +30435,69 @@ void x64Parser::TokenFunc7425(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7415[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7425, x64Parser::tokenBranches7425 }, +x64Token x64Parser::tokenBranches7421[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7422 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7431, x64Parser::tokenBranches7431 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7414[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7415 }, +x64Token x64Parser::tokenBranches7420[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7421 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7413[] = { - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7414 }, +x64Token x64Parser::tokenBranches7419[] = { + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7420 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7412[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7413 }, +x64Token x64Parser::tokenBranches7418[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7419 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7411[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7412 }, +x64Token x64Parser::tokenBranches7417[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7418 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7410[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7411 }, +x64Token x64Parser::tokenBranches7416[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7417 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7357[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7358 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7410 }, +x64Token x64Parser::tokenBranches7363[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7364 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7416 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7441(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7447(x64Operand &operand, int tokenPos) { - operand.operandCoding = 618; + operand.operandCoding = 619; } -x64Token x64Parser::tokenBranches7440[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7441, }, +x64Token x64Parser::tokenBranches7446[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7447, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7439[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, +x64Token x64Parser::tokenBranches7445[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7446 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7438[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, +x64Token x64Parser::tokenBranches7444[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7445 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7454(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7460(x64Operand &operand, int tokenPos) { - operand.operandCoding = 619; + operand.operandCoding = 620; } -x64Token x64Parser::tokenBranches7453[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7454, }, +x64Token x64Parser::tokenBranches7459[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7460, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7452[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7453 }, +x64Token x64Parser::tokenBranches7458[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7451[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7452 }, +x64Token x64Parser::tokenBranches7457[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7458 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7457(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30440,60 +30509,60 @@ void x64Parser::TokenFunc7451(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7437[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7451, x64Parser::tokenBranches7451 }, +x64Token x64Parser::tokenBranches7443[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7444 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7457, x64Parser::tokenBranches7457 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7436[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, +x64Token x64Parser::tokenBranches7442[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7443 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7435[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, +x64Token x64Parser::tokenBranches7441[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7442 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7434[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, +x64Token x64Parser::tokenBranches7440[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7441 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7433[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7434 }, +x64Token x64Parser::tokenBranches7439[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7440 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7467(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7473(x64Operand &operand, int tokenPos) { - operand.operandCoding = 620; + operand.operandCoding = 621; } -x64Token x64Parser::tokenBranches7466[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7467, }, +x64Token x64Parser::tokenBranches7472[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7473, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7465[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, +x64Token x64Parser::tokenBranches7471[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7472 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7464[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, +x64Token x64Parser::tokenBranches7470[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7471 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7480(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7486(x64Operand &operand, int tokenPos) { - operand.operandCoding = 621; + operand.operandCoding = 622; } -x64Token x64Parser::tokenBranches7479[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7480, }, +x64Token x64Parser::tokenBranches7485[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7486, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7478[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7479 }, +x64Token x64Parser::tokenBranches7484[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7477[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7478 }, +x64Token x64Parser::tokenBranches7483[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7483(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30505,65 +30574,65 @@ void x64Parser::TokenFunc7477(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7463[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7464 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7477, x64Parser::tokenBranches7477 }, +x64Token x64Parser::tokenBranches7469[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7470 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7483, x64Parser::tokenBranches7483 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7462[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7463 }, +x64Token x64Parser::tokenBranches7468[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7469 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7461[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7462 }, +x64Token x64Parser::tokenBranches7467[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7468 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7460[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7461 }, +x64Token x64Parser::tokenBranches7466[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7467 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7459[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7460 }, +x64Token x64Parser::tokenBranches7465[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7466 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7432[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7433 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7459 }, +x64Token x64Parser::tokenBranches7438[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7439 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7465 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7431[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7432 }, +x64Token x64Parser::tokenBranches7437[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7438 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7430[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7431 }, +x64Token x64Parser::tokenBranches7436[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7437 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7489(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7495(x64Operand &operand, int tokenPos) { - operand.operandCoding = 622; + operand.operandCoding = 623; } -x64Token x64Parser::tokenBranches7488[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7489, }, +x64Token x64Parser::tokenBranches7494[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7495, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7500(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7506(x64Operand &operand, int tokenPos) { - operand.operandCoding = 623; + operand.operandCoding = 624; } -x64Token x64Parser::tokenBranches7499[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7500, }, +x64Token x64Parser::tokenBranches7505[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7506, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7498[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7499 }, +x64Token x64Parser::tokenBranches7504[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7497[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7498 }, +x64Token x64Parser::tokenBranches7503[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7503(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30575,69 +30644,69 @@ void x64Parser::TokenFunc7497(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7487[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7497, x64Parser::tokenBranches7497 }, +x64Token x64Parser::tokenBranches7493[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7494 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7503, x64Parser::tokenBranches7503 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7486[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7487 }, +x64Token x64Parser::tokenBranches7492[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7493 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7485[] = { - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7486 }, +x64Token x64Parser::tokenBranches7491[] = { + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7492 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7484[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7485 }, +x64Token x64Parser::tokenBranches7490[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7491 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7483[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7484 }, +x64Token x64Parser::tokenBranches7489[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7490 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7482[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7483 }, +x64Token x64Parser::tokenBranches7488[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7489 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7429[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7430 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7482 }, +x64Token x64Parser::tokenBranches7435[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7436 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7488 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7513(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7519(x64Operand &operand, int tokenPos) { - operand.operandCoding = 624; + operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7512[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7513, }, +x64Token x64Parser::tokenBranches7518[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7519, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7511[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, +x64Token x64Parser::tokenBranches7517[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7518 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7510[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, +x64Token x64Parser::tokenBranches7516[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7517 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7526(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7532(x64Operand &operand, int tokenPos) { - operand.operandCoding = 625; + operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7525[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7526, }, +x64Token x64Parser::tokenBranches7531[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7532, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7524[] = { - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7525 }, +x64Token x64Parser::tokenBranches7530[] = { + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7523[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7524 }, +x64Token x64Parser::tokenBranches7529[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7529(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30649,64 +30718,64 @@ void x64Parser::TokenFunc7523(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7509[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7523, x64Parser::tokenBranches7523 }, +x64Token x64Parser::tokenBranches7515[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7516 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7529, x64Parser::tokenBranches7529 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7508[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, +x64Token x64Parser::tokenBranches7514[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7515 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7507[] = { - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, +x64Token x64Parser::tokenBranches7513[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7514 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7506[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, +x64Token x64Parser::tokenBranches7512[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7513 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7505[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7506 }, +x64Token x64Parser::tokenBranches7511[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7512 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7504[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7505 }, +x64Token x64Parser::tokenBranches7510[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7511 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7503[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7504 }, +x64Token x64Parser::tokenBranches7509[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7510 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7502[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7503 }, +x64Token x64Parser::tokenBranches7508[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7509 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7535(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7541(x64Operand &operand, int tokenPos) { - operand.operandCoding = 624; + operand.operandCoding = 625; } -x64Token x64Parser::tokenBranches7534[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7535, }, +x64Token x64Parser::tokenBranches7540[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7541, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7546(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) { - operand.operandCoding = 625; + operand.operandCoding = 626; } -x64Token x64Parser::tokenBranches7545[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7546, }, +x64Token x64Parser::tokenBranches7551[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7552, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7544[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7545 }, +x64Token x64Parser::tokenBranches7550[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7551 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7543[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7544 }, +x64Token x64Parser::tokenBranches7549[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7550 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7549(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -30718,170 +30787,170 @@ void x64Parser::TokenFunc7543(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7533[] = { - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7543, x64Parser::tokenBranches7543 }, +x64Token x64Parser::tokenBranches7539[] = { + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7540 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7549, x64Parser::tokenBranches7549 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7532[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7533 }, +x64Token x64Parser::tokenBranches7538[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7539 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7531[] = { - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7532 }, +x64Token x64Parser::tokenBranches7537[] = { + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7538 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7530[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7531 }, +x64Token x64Parser::tokenBranches7536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7537 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7529[] = { - {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7530 }, +x64Token x64Parser::tokenBranches7535[] = { + {x64Token::TOKEN, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches7536 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7528[] = { - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7529 }, +x64Token x64Parser::tokenBranches7534[] = { + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7535 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7501[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7502 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7528 }, +x64Token x64Parser::tokenBranches7507[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7508 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7534 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7284[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7285 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7357 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7429 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7501 }, +x64Token x64Parser::tokenBranches7290[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7291 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7363 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7435 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7507 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7551_16[] = { +Coding x64Parser::tokenCoding7557_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_17[] = { +Coding x64Parser::tokenCoding7557_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_18[] = { +Coding x64Parser::tokenCoding7557_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7551_19[] = { +Coding x64Parser::tokenCoding7557_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7551(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7557(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7551_16; - operand.values[17] = tokenCoding7551_17; - operand.values[18] = tokenCoding7551_18; - operand.values[19] = tokenCoding7551_19; + operand.values[16] = tokenCoding7557_16; + operand.values[17] = tokenCoding7557_17; + operand.values[18] = tokenCoding7557_18; + operand.values[19] = tokenCoding7557_19; } -x64Token x64Parser::tokenBranches7550[] = { - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7551, }, +x64Token x64Parser::tokenBranches7556[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7557, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7549[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7550 }, +x64Token x64Parser::tokenBranches7555[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7556 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7548[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7549 }, +x64Token x64Parser::tokenBranches7554[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7555 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7555_16[] = { +Coding x64Parser::tokenCoding7561_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_17[] = { +Coding x64Parser::tokenCoding7561_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_18[] = { +Coding x64Parser::tokenCoding7561_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7555_19[] = { +Coding x64Parser::tokenCoding7561_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7555(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7561(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7555_16; - operand.values[17] = tokenCoding7555_17; - operand.values[18] = tokenCoding7555_18; - operand.values[19] = tokenCoding7555_19; + operand.values[16] = tokenCoding7561_16; + operand.values[17] = tokenCoding7561_17; + operand.values[18] = tokenCoding7561_18; + operand.values[19] = tokenCoding7561_19; } -x64Token x64Parser::tokenBranches7554[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7555, }, +x64Token x64Parser::tokenBranches7560[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7561, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7553[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7554 }, +x64Token x64Parser::tokenBranches7559[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7552[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7553 }, +x64Token x64Parser::tokenBranches7558[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7559 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7559_16[] = { +Coding x64Parser::tokenCoding7565_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_17[] = { +Coding x64Parser::tokenCoding7565_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_18[] = { +Coding x64Parser::tokenCoding7565_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7559_19[] = { +Coding x64Parser::tokenCoding7565_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7559(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7565(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7559_16; - operand.values[17] = tokenCoding7559_17; - operand.values[18] = tokenCoding7559_18; - operand.values[19] = tokenCoding7559_19; + operand.values[16] = tokenCoding7565_16; + operand.values[17] = tokenCoding7565_17; + operand.values[18] = tokenCoding7565_18; + operand.values[19] = tokenCoding7565_19; } -x64Token x64Parser::tokenBranches7558[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7559, }, +x64Token x64Parser::tokenBranches7564[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7565, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7557[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7558 }, +x64Token x64Parser::tokenBranches7563[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7556[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7557 }, +x64Token x64Parser::tokenBranches7562[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7563 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7563_16[] = { +Coding x64Parser::tokenCoding7569_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_17[] = { +Coding x64Parser::tokenCoding7569_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_18[] = { +Coding x64Parser::tokenCoding7569_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7563_19[] = { +Coding x64Parser::tokenCoding7569_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7569(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30892,42 +30961,42 @@ void x64Parser::TokenFunc7563(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7563_16; - operand.values[17] = tokenCoding7563_17; - operand.values[18] = tokenCoding7563_18; - operand.values[19] = tokenCoding7563_19; + operand.values[16] = tokenCoding7569_16; + operand.values[17] = tokenCoding7569_17; + operand.values[18] = tokenCoding7569_18; + operand.values[19] = tokenCoding7569_19; } -x64Token x64Parser::tokenBranches7562[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7563, }, +x64Token x64Parser::tokenBranches7568[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7569, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7561[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7562 }, +x64Token x64Parser::tokenBranches7567[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7568 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7560[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7561 }, +x64Token x64Parser::tokenBranches7566[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches7567 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7567_16[] = { +Coding x64Parser::tokenCoding7573_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_17[] = { +Coding x64Parser::tokenCoding7573_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_18[] = { +Coding x64Parser::tokenCoding7573_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7567_19[] = { +Coding x64Parser::tokenCoding7573_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7573(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30938,42 +31007,42 @@ void x64Parser::TokenFunc7567(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7567_16; - operand.values[17] = tokenCoding7567_17; - operand.values[18] = tokenCoding7567_18; - operand.values[19] = tokenCoding7567_19; + operand.values[16] = tokenCoding7573_16; + operand.values[17] = tokenCoding7573_17; + operand.values[18] = tokenCoding7573_18; + operand.values[19] = tokenCoding7573_19; } -x64Token x64Parser::tokenBranches7566[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7567, }, +x64Token x64Parser::tokenBranches7572[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7573, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7565[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7566 }, +x64Token x64Parser::tokenBranches7571[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7572 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7564[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7565 }, +x64Token x64Parser::tokenBranches7570[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches7571 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7571_16[] = { +Coding x64Parser::tokenCoding7577_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_17[] = { +Coding x64Parser::tokenCoding7577_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_18[] = { +Coding x64Parser::tokenCoding7577_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7571_19[] = { +Coding x64Parser::tokenCoding7577_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::indirect), 36, 0, 0, 0, '+' }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -30984,24 +31053,24 @@ void x64Parser::TokenFunc7571(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7571_16; - operand.values[17] = tokenCoding7571_17; - operand.values[18] = tokenCoding7571_18; - operand.values[19] = tokenCoding7571_19; + operand.values[16] = tokenCoding7577_16; + operand.values[17] = tokenCoding7577_17; + operand.values[18] = tokenCoding7577_18; + operand.values[19] = tokenCoding7577_19; } -x64Token x64Parser::tokenBranches7570[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7571, }, +x64Token x64Parser::tokenBranches7576[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7577, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7569[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7570 }, +x64Token x64Parser::tokenBranches7575[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7568[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7569 }, +x64Token x64Parser::tokenBranches7574[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7575 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7554(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31013,7 +31082,7 @@ void x64Parser::TokenFunc7548(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7558(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31025,7 +31094,7 @@ void x64Parser::TokenFunc7552(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7562(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31037,74 +31106,74 @@ void x64Parser::TokenFunc7556(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7547[] = { - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7548, x64Parser::tokenBranches7548 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7552, x64Parser::tokenBranches7552 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7556, x64Parser::tokenBranches7556 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7560 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7564 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7568 }, +x64Token x64Parser::tokenBranches7553[] = { + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc7554, x64Parser::tokenBranches7554 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7558, x64Parser::tokenBranches7558 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7562, x64Parser::tokenBranches7562 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7566 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7570 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7574 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7577_16[] = { +Coding x64Parser::tokenCoding7583_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_17[] = { +Coding x64Parser::tokenCoding7583_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_23[] = { +Coding x64Parser::tokenCoding7583_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_18[] = { +Coding x64Parser::tokenCoding7583_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7577_19[] = { +Coding x64Parser::tokenCoding7583_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7577(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7577_16; - operand.values[17] = tokenCoding7577_17; - operand.values[23] = tokenCoding7577_23; - operand.values[18] = tokenCoding7577_18; - operand.values[19] = tokenCoding7577_19; + operand.values[16] = tokenCoding7583_16; + operand.values[17] = tokenCoding7583_17; + operand.values[23] = tokenCoding7583_23; + operand.values[18] = tokenCoding7583_18; + operand.values[19] = tokenCoding7583_19; } -x64Token x64Parser::tokenBranches7576[] = { - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7577, }, +x64Token x64Parser::tokenBranches7582[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc7583, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7575[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7576 }, +x64Token x64Parser::tokenBranches7581[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7582 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7580_16[] = { +Coding x64Parser::tokenCoding7586_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_17[] = { +Coding x64Parser::tokenCoding7586_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_23[] = { +Coding x64Parser::tokenCoding7586_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_18[] = { +Coding x64Parser::tokenCoding7586_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7580_19[] = { +Coding x64Parser::tokenCoding7586_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 17, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7586(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31115,21 +31184,21 @@ void x64Parser::TokenFunc7580(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding7580_16; - operand.values[17] = tokenCoding7580_17; - operand.values[23] = tokenCoding7580_23; - operand.values[18] = tokenCoding7580_18; - operand.values[19] = tokenCoding7580_19; + operand.values[16] = tokenCoding7586_16; + operand.values[17] = tokenCoding7586_17; + operand.values[23] = tokenCoding7586_23; + operand.values[18] = tokenCoding7586_18; + operand.values[19] = tokenCoding7586_19; } -x64Token x64Parser::tokenBranches7579[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7580, }, +x64Token x64Parser::tokenBranches7585[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc7586, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7578[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7579 }, +x64Token x64Parser::tokenBranches7584[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7585 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31141,147 +31210,147 @@ void x64Parser::TokenFunc7575(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7581(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) { - operand.operandCoding = 626; + operand.operandCoding = 627; } -x64Token x64Parser::tokenBranches7574[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7575, x64Parser::tokenBranches7575 }, - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7578 }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7581, }, +x64Token x64Parser::tokenBranches7580[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc7581, x64Parser::tokenBranches7581 }, + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7584 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7587, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7583(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) { - operand.operandCoding = 627; + operand.operandCoding = 628; } -x64Token x64Parser::tokenBranches7582[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7583, }, +x64Token x64Parser::tokenBranches7588[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7589, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7593_16[] = { +Coding x64Parser::tokenCoding7599_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_17[] = { +Coding x64Parser::tokenCoding7599_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_18[] = { +Coding x64Parser::tokenCoding7599_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7593_19[] = { +Coding x64Parser::tokenCoding7599_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7599(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7593_16; - operand.values[17] = tokenCoding7593_17; - operand.values[18] = tokenCoding7593_18; - operand.values[19] = tokenCoding7593_19; + operand.values[16] = tokenCoding7599_16; + operand.values[17] = tokenCoding7599_17; + operand.values[18] = tokenCoding7599_18; + operand.values[19] = tokenCoding7599_19; } -x64Token x64Parser::tokenBranches7592[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7593, }, +x64Token x64Parser::tokenBranches7598[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7599, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7589_16[] = { +Coding x64Parser::tokenCoding7595_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_17[] = { +Coding x64Parser::tokenCoding7595_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_18[] = { +Coding x64Parser::tokenCoding7595_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7589_19[] = { +Coding x64Parser::tokenCoding7595_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7589(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7595(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7589_16; - operand.values[17] = tokenCoding7589_17; - operand.values[18] = tokenCoding7589_18; - operand.values[19] = tokenCoding7589_19; + operand.values[16] = tokenCoding7595_16; + operand.values[17] = tokenCoding7595_17; + operand.values[18] = tokenCoding7595_18; + operand.values[19] = tokenCoding7595_19; } -x64Token x64Parser::tokenBranches7588[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7589, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7592 }, +x64Token x64Parser::tokenBranches7594[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7595, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7598 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7587[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7588 }, +x64Token x64Parser::tokenBranches7593[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7594 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7600_16[] = { +Coding x64Parser::tokenCoding7606_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_17[] = { +Coding x64Parser::tokenCoding7606_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_18[] = { +Coding x64Parser::tokenCoding7606_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7600_19[] = { +Coding x64Parser::tokenCoding7606_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7606(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7600_16; - operand.values[17] = tokenCoding7600_17; - operand.values[18] = tokenCoding7600_18; - operand.values[19] = tokenCoding7600_19; + operand.values[16] = tokenCoding7606_16; + operand.values[17] = tokenCoding7606_17; + operand.values[18] = tokenCoding7606_18; + operand.values[19] = tokenCoding7606_19; } -x64Token x64Parser::tokenBranches7599[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7600, }, +x64Token x64Parser::tokenBranches7605[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc7606, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7596_16[] = { +Coding x64Parser::tokenCoding7602_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_17[] = { +Coding x64Parser::tokenCoding7602_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_18[] = { +Coding x64Parser::tokenCoding7602_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7596_19[] = { +Coding x64Parser::tokenCoding7602_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7596(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7602(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7596_16; - operand.values[17] = tokenCoding7596_17; - operand.values[18] = tokenCoding7596_18; - operand.values[19] = tokenCoding7596_19; + operand.values[16] = tokenCoding7602_16; + operand.values[17] = tokenCoding7602_17; + operand.values[18] = tokenCoding7602_18; + operand.values[19] = tokenCoding7602_19; } -x64Token x64Parser::tokenBranches7595[] = { - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7596, }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7599 }, +x64Token x64Parser::tokenBranches7601[] = { + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7602, }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7605 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7594[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7595 }, +x64Token x64Parser::tokenBranches7600[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7601 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7593(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31293,7 +31362,7 @@ void x64Parser::TokenFunc7587(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7600(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -31305,24 +31374,24 @@ void x64Parser::TokenFunc7594(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7586[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7587, x64Parser::tokenBranches7587 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7594, x64Parser::tokenBranches7594 }, +x64Token x64Parser::tokenBranches7592[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc7593, x64Parser::tokenBranches7593 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc7600, x64Parser::tokenBranches7600 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7610(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) { - operand.operandCoding = 628; + operand.operandCoding = 629; } -x64Token x64Parser::tokenBranches7609[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7610, }, +x64Token x64Parser::tokenBranches7615[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7616, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7608[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7609 }, +x64Token x64Parser::tokenBranches7614[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7615 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31335,23 +31404,23 @@ void x64Parser::TokenFunc7608(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7607[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7608, x64Parser::tokenBranches7608 }, +x64Token x64Parser::tokenBranches7613[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7614, x64Parser::tokenBranches7614 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7614(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) { - operand.operandCoding = 629; + operand.operandCoding = 630; } -x64Token x64Parser::tokenBranches7613[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7614, }, +x64Token x64Parser::tokenBranches7619[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7620, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7612[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7613 }, +x64Token x64Parser::tokenBranches7618[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7619 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31364,23 +31433,23 @@ void x64Parser::TokenFunc7612(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7611[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7612, x64Parser::tokenBranches7612 }, +x64Token x64Parser::tokenBranches7617[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7618, x64Parser::tokenBranches7618 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7618(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7624(x64Operand &operand, int tokenPos) { - operand.operandCoding = 630; + operand.operandCoding = 631; } -x64Token x64Parser::tokenBranches7617[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7618, }, +x64Token x64Parser::tokenBranches7623[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7624, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7616[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7617 }, +x64Token x64Parser::tokenBranches7622[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31393,23 +31462,23 @@ void x64Parser::TokenFunc7616(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7615[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7616, x64Parser::tokenBranches7616 }, +x64Token x64Parser::tokenBranches7621[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7622, x64Parser::tokenBranches7622 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7622(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) { - operand.operandCoding = 631; + operand.operandCoding = 632; } -x64Token x64Parser::tokenBranches7621[] = { - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7622, }, +x64Token x64Parser::tokenBranches7627[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7628, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7620[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7621 }, +x64Token x64Parser::tokenBranches7626[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7627 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7626(x64Operand &operand, int tokenPos) { operand.values[29] = new Coding[2]; CleanupValues.push_back(operand.values[29]); @@ -31422,113 +31491,113 @@ void x64Parser::TokenFunc7620(x64Operand &operand, int tokenPos) operand.values[29][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7619[] = { - {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7620, x64Parser::tokenBranches7620 }, +x64Token x64Parser::tokenBranches7625[] = { + {x64Token::NUMBER, 3, 0, 0, NULL,&x64Parser::TokenFunc7626, x64Parser::tokenBranches7626 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7625(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 632; -} -void x64Parser::TokenFunc7628(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) { operand.operandCoding = 633; } -void x64Parser::TokenFunc7631(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) { operand.operandCoding = 634; } -void x64Parser::TokenFunc7634(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7637(x64Operand &operand, int tokenPos) { operand.operandCoding = 635; } -x64Token x64Parser::tokenBranches7624[] = { - {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7625, }, - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7628, }, - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7631, }, - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7634, }, +void x64Parser::TokenFunc7640(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 636; +} +x64Token x64Parser::tokenBranches7630[] = { + {x64Token::REGISTER, 0, 1, 0, NULL,&x64Parser::TokenFunc7631, }, + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc7634, }, + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc7637, }, + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc7640, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7623[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7624 }, +x64Token x64Parser::tokenBranches7629[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7630 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7606[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7607 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7611 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7615 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7619 }, - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7623 }, +x64Token x64Parser::tokenBranches7612[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7613 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches7617 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches7621 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches7625 }, + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7629 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7643(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7649(x64Operand &operand, int tokenPos) { - operand.operandCoding = 636; + operand.operandCoding = 637; } -x64Token x64Parser::tokenBranches7642[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7643, }, +x64Token x64Parser::tokenBranches7648[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7649, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7659(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7665(x64Operand &operand, int tokenPos) { - operand.operandCoding = 638; + operand.operandCoding = 639; } -x64Token x64Parser::tokenBranches7658[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7659, }, +x64Token x64Parser::tokenBranches7664[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7665, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7641[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7658 }, +x64Token x64Parser::tokenBranches7647[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7648 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7664 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7640[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7641 }, +x64Token x64Parser::tokenBranches7646[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7647 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7651(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7657(x64Operand &operand, int tokenPos) { - operand.operandCoding = 637; + operand.operandCoding = 638; } -x64Token x64Parser::tokenBranches7650[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7651, }, +x64Token x64Parser::tokenBranches7656[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7657, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7667(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) { - operand.operandCoding = 639; + operand.operandCoding = 640; } -x64Token x64Parser::tokenBranches7666[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7667, }, +x64Token x64Parser::tokenBranches7672[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7681(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7687(x64Operand &operand, int tokenPos) { - operand.operandCoding = 641; + operand.operandCoding = 642; } -x64Token x64Parser::tokenBranches7680[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7681, }, +x64Token x64Parser::tokenBranches7686[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7687, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7649[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7650 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7666 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7680 }, +x64Token x64Parser::tokenBranches7655[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7656 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7648[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7649 }, +x64Token x64Parser::tokenBranches7654[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7655 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7673(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7679(x64Operand &operand, int tokenPos) { - operand.operandCoding = 640; + operand.operandCoding = 641; } -x64Token x64Parser::tokenBranches7672[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7673, }, +x64Token x64Parser::tokenBranches7678[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7679, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7654(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31540,84 +31609,84 @@ void x64Parser::TokenFunc7648(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7639[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7640 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7648, x64Parser::tokenBranches7648 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7672 }, +x64Token x64Parser::tokenBranches7645[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7646 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7654, x64Parser::tokenBranches7654 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7678 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7638[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7639 }, +x64Token x64Parser::tokenBranches7644[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7645 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7689(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7695(x64Operand &operand, int tokenPos) { - operand.operandCoding = 642; + operand.operandCoding = 643; } -x64Token x64Parser::tokenBranches7688[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7689, }, +x64Token x64Parser::tokenBranches7694[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7695, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7705(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7711(x64Operand &operand, int tokenPos) { - operand.operandCoding = 644; + operand.operandCoding = 645; } -x64Token x64Parser::tokenBranches7704[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7705, }, +x64Token x64Parser::tokenBranches7710[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7711, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7687[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7688 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7704 }, +x64Token x64Parser::tokenBranches7693[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7694 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7710 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7686[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7687 }, +x64Token x64Parser::tokenBranches7692[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7693 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7697(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7703(x64Operand &operand, int tokenPos) { - operand.operandCoding = 643; + operand.operandCoding = 644; } -x64Token x64Parser::tokenBranches7696[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7697, }, +x64Token x64Parser::tokenBranches7702[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7703, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7713(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) { - operand.operandCoding = 645; + operand.operandCoding = 646; } -x64Token x64Parser::tokenBranches7712[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7713, }, +x64Token x64Parser::tokenBranches7718[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7727(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7733(x64Operand &operand, int tokenPos) { - operand.operandCoding = 647; + operand.operandCoding = 648; } -x64Token x64Parser::tokenBranches7726[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7727, }, +x64Token x64Parser::tokenBranches7732[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7733, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7695[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7696 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7712 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7726 }, +x64Token x64Parser::tokenBranches7701[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7702 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7694[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7695 }, +x64Token x64Parser::tokenBranches7700[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7701 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7719(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7725(x64Operand &operand, int tokenPos) { - operand.operandCoding = 646; + operand.operandCoding = 647; } -x64Token x64Parser::tokenBranches7718[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7719, }, +x64Token x64Parser::tokenBranches7724[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7725, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7700(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31629,84 +31698,84 @@ void x64Parser::TokenFunc7694(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7685[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7686 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7694, x64Parser::tokenBranches7694 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7718 }, +x64Token x64Parser::tokenBranches7691[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7692 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7700, x64Parser::tokenBranches7700 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7724 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7684[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7685 }, +x64Token x64Parser::tokenBranches7690[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7691 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7735(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7741(x64Operand &operand, int tokenPos) { - operand.operandCoding = 648; + operand.operandCoding = 649; } -x64Token x64Parser::tokenBranches7734[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7735, }, +x64Token x64Parser::tokenBranches7740[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7741, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7751(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7757(x64Operand &operand, int tokenPos) { - operand.operandCoding = 650; + operand.operandCoding = 651; } -x64Token x64Parser::tokenBranches7750[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7751, }, +x64Token x64Parser::tokenBranches7756[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7757, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7733[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7734 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7750 }, +x64Token x64Parser::tokenBranches7739[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7740 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7756 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7732[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7733 }, +x64Token x64Parser::tokenBranches7738[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7739 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7743(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7749(x64Operand &operand, int tokenPos) { - operand.operandCoding = 649; + operand.operandCoding = 650; } -x64Token x64Parser::tokenBranches7742[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7743, }, +x64Token x64Parser::tokenBranches7748[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7749, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7759(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) { - operand.operandCoding = 651; + operand.operandCoding = 652; } -x64Token x64Parser::tokenBranches7758[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7759, }, +x64Token x64Parser::tokenBranches7764[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7773(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) { - operand.operandCoding = 653; + operand.operandCoding = 654; } -x64Token x64Parser::tokenBranches7772[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7773, }, +x64Token x64Parser::tokenBranches7778[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7779, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7741[] = { - {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7742 }, - {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7758 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7772 }, +x64Token x64Parser::tokenBranches7747[] = { + {x64Token::REGISTER, 53, 0, 0, NULL, NULL, x64Parser::tokenBranches7748 }, + {x64Token::REGISTER, 54, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7778 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7740[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7741 }, +x64Token x64Parser::tokenBranches7746[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7747 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7765(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7771(x64Operand &operand, int tokenPos) { - operand.operandCoding = 652; + operand.operandCoding = 653; } -x64Token x64Parser::tokenBranches7764[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7765, }, +x64Token x64Parser::tokenBranches7770[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7771, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7746(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -31718,117 +31787,117 @@ void x64Parser::TokenFunc7740(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7731[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7732 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7740, x64Parser::tokenBranches7740 }, - {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7764 }, +x64Token x64Parser::tokenBranches7737[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches7738 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7746, x64Parser::tokenBranches7746 }, + {x64Token::REGISTER, 55, 0, 0, NULL, NULL, x64Parser::tokenBranches7770 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7730[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7731 }, +x64Token x64Parser::tokenBranches7736[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7737 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7637[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7638 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7684 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7730 }, +x64Token x64Parser::tokenBranches7643[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7644 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7690 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7736 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7636[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7637 }, +x64Token x64Parser::tokenBranches7642[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches7643 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7635[] = { - {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7636 }, +x64Token x64Parser::tokenBranches7641[] = { + {x64Token::REGISTER, 20, 0, 0, NULL, NULL, x64Parser::tokenBranches7642 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7782_16[] = { +Coding x64Parser::tokenCoding7788_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_17[] = { +Coding x64Parser::tokenCoding7788_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_18[] = { +Coding x64Parser::tokenCoding7788_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7782_19[] = { +Coding x64Parser::tokenCoding7788_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7782(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7782_16; - operand.values[17] = tokenCoding7782_17; - operand.values[18] = tokenCoding7782_18; - operand.values[19] = tokenCoding7782_19; + operand.values[16] = tokenCoding7788_16; + operand.values[17] = tokenCoding7788_17; + operand.values[18] = tokenCoding7788_18; + operand.values[19] = tokenCoding7788_19; } -x64Token x64Parser::tokenBranches7781[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7782, }, +x64Token x64Parser::tokenBranches7787[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7788, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7784_16[] = { +Coding x64Parser::tokenCoding7790_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_17[] = { +Coding x64Parser::tokenCoding7790_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_18[] = { +Coding x64Parser::tokenCoding7790_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7784_19[] = { +Coding x64Parser::tokenCoding7790_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7790(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7784_16; - operand.values[17] = tokenCoding7784_17; - operand.values[18] = tokenCoding7784_18; - operand.values[19] = tokenCoding7784_19; + operand.values[16] = tokenCoding7790_16; + operand.values[17] = tokenCoding7790_17; + operand.values[18] = tokenCoding7790_18; + operand.values[19] = tokenCoding7790_19; } -x64Token x64Parser::tokenBranches7783[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7784, }, +x64Token x64Parser::tokenBranches7789[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7790, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7786_16[] = { +Coding x64Parser::tokenCoding7792_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_17[] = { +Coding x64Parser::tokenCoding7792_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_18[] = { +Coding x64Parser::tokenCoding7792_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7786_19[] = { +Coding x64Parser::tokenCoding7792_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 143, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7792(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding7786_16; - operand.values[17] = tokenCoding7786_17; - operand.values[18] = tokenCoding7786_18; - operand.values[19] = tokenCoding7786_19; + operand.values[16] = tokenCoding7792_16; + operand.values[17] = tokenCoding7792_17; + operand.values[18] = tokenCoding7792_18; + operand.values[19] = tokenCoding7792_19; } -x64Token x64Parser::tokenBranches7785[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7786, }, +x64Token x64Parser::tokenBranches7791[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7792, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7784(x64Operand &operand, int tokenPos) { - operand.operandCoding = 654; + operand.operandCoding = 655; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31839,9 +31908,9 @@ void x64Parser::TokenFunc7778(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7785(x64Operand &operand, int tokenPos) { - operand.operandCoding = 655; + operand.operandCoding = 656; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31852,9 +31921,9 @@ void x64Parser::TokenFunc7779(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7786(x64Operand &operand, int tokenPos) { - operand.operandCoding = 656; + operand.operandCoding = 657; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -31865,17 +31934,17 @@ void x64Parser::TokenFunc7780(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7787(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 657; -} -void x64Parser::TokenFunc7788(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7793(x64Operand &operand, int tokenPos) { operand.operandCoding = 658; } -void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7794(x64Operand &operand, int tokenPos) { operand.operandCoding = 659; +} +void x64Parser::TokenFunc7795(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 660; operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); operand.values[2]->type = Coding::reg; @@ -31886,189 +31955,171 @@ void x64Parser::TokenFunc7789(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7777[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7778, }, - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7779, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7780, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7781 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7783 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7785 }, - {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7787, }, - {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7788, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7789, }, +x64Token x64Parser::tokenBranches7783[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7784, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7785, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7786, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7787 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7789 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7791 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7793, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7794, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7795, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7799_34[] = { +Coding x64Parser::tokenCoding7805_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_16[] = { +Coding x64Parser::tokenCoding7805_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_17[] = { +Coding x64Parser::tokenCoding7805_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_35[] = { +Coding x64Parser::tokenCoding7805_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_18[] = { +Coding x64Parser::tokenCoding7805_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7799_19[] = { +Coding x64Parser::tokenCoding7805_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7799(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7799_34; - operand.values[16] = tokenCoding7799_16; - operand.values[17] = tokenCoding7799_17; - operand.values[35] = tokenCoding7799_35; - operand.values[18] = tokenCoding7799_18; - operand.values[19] = tokenCoding7799_19; + operand.values[34] = tokenCoding7805_34; + operand.values[16] = tokenCoding7805_16; + operand.values[17] = tokenCoding7805_17; + operand.values[35] = tokenCoding7805_35; + operand.values[18] = tokenCoding7805_18; + operand.values[19] = tokenCoding7805_19; } -x64Token x64Parser::tokenBranches7798[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7799, }, +x64Token x64Parser::tokenBranches7804[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7801_34[] = { +Coding x64Parser::tokenCoding7807_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_16[] = { +Coding x64Parser::tokenCoding7807_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_17[] = { +Coding x64Parser::tokenCoding7807_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_35[] = { +Coding x64Parser::tokenCoding7807_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_18[] = { +Coding x64Parser::tokenCoding7807_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7801_19[] = { +Coding x64Parser::tokenCoding7807_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7801(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7801_34; - operand.values[16] = tokenCoding7801_16; - operand.values[17] = tokenCoding7801_17; - operand.values[35] = tokenCoding7801_35; - operand.values[18] = tokenCoding7801_18; - operand.values[19] = tokenCoding7801_19; + operand.values[34] = tokenCoding7807_34; + operand.values[16] = tokenCoding7807_16; + operand.values[17] = tokenCoding7807_17; + operand.values[35] = tokenCoding7807_35; + operand.values[18] = tokenCoding7807_18; + operand.values[19] = tokenCoding7807_19; } -x64Token x64Parser::tokenBranches7800[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7801, }, +x64Token x64Parser::tokenBranches7806[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7807, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7803_34[] = { +Coding x64Parser::tokenCoding7809_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_16[] = { +Coding x64Parser::tokenCoding7809_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_17[] = { +Coding x64Parser::tokenCoding7809_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_35[] = { +Coding x64Parser::tokenCoding7809_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_18[] = { +Coding x64Parser::tokenCoding7809_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7803_19[] = { +Coding x64Parser::tokenCoding7809_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7803(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) { - operand.values[34] = tokenCoding7803_34; - operand.values[16] = tokenCoding7803_16; - operand.values[17] = tokenCoding7803_17; - operand.values[35] = tokenCoding7803_35; - operand.values[18] = tokenCoding7803_18; - operand.values[19] = tokenCoding7803_19; + operand.values[34] = tokenCoding7809_34; + operand.values[16] = tokenCoding7809_16; + operand.values[17] = tokenCoding7809_17; + operand.values[35] = tokenCoding7809_35; + operand.values[18] = tokenCoding7809_18; + operand.values[19] = tokenCoding7809_19; } -x64Token x64Parser::tokenBranches7802[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7803, }, +x64Token x64Parser::tokenBranches7808[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7809, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding7805_34[] = { +Coding x64Parser::tokenCoding7811_34[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_16[] = { +Coding x64Parser::tokenCoding7811_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_17[] = { +Coding x64Parser::tokenCoding7811_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_35[] = { +Coding x64Parser::tokenCoding7811_35[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_18[] = { +Coding x64Parser::tokenCoding7811_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7805_19[] = { +Coding x64Parser::tokenCoding7811_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7805(x64Operand &operand, int tokenPos) -{ - operand.values[34] = tokenCoding7805_34; - operand.values[16] = tokenCoding7805_16; - operand.values[17] = tokenCoding7805_17; - operand.values[35] = tokenCoding7805_35; - operand.values[18] = tokenCoding7805_18; - operand.values[19] = tokenCoding7805_19; -} -x64Token x64Parser::tokenBranches7804[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7805, }, - {x64Token::EOT } -}; void x64Parser::TokenFunc7811(x64Operand &operand, int tokenPos) { - operand.operandCoding = 663; - operand.values[22] = new Coding[2]; - CleanupValues.push_back(operand.values[22]); - operand.values[22]->type = Coding::number; - operand.values[22]->val = operands.size(); - operand.values[22]->bits = 0; - operand.values[22]->field = 0; - operand.values[22]->unary = 0; - operand.values[22]->binary = 0; - operand.values[22][1].type = Coding::eot; - operands.push_back(numeric); + operand.values[34] = tokenCoding7811_34; + operand.values[16] = tokenCoding7811_16; + operand.values[17] = tokenCoding7811_17; + operand.values[35] = tokenCoding7811_35; + operand.values[18] = tokenCoding7811_18; + operand.values[19] = tokenCoding7811_19; } x64Token x64Parser::tokenBranches7810[] = { - {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7811, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7817(x64Operand &operand, int tokenPos) { operand.operandCoding = 664; operand.values[22] = new Coding[2]; @@ -32082,37 +32133,11 @@ void x64Parser::TokenFunc7816(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7822_16[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_17[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_18[] = { - { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding7822_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 4 }, - { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 667; - operand.values[16] = tokenCoding7822_16; - operand.values[17] = tokenCoding7822_17; - operand.values[18] = tokenCoding7822_18; - operand.values[19] = tokenCoding7822_19; -} -x64Token x64Parser::tokenBranches7815[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7816, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7822, }, +x64Token x64Parser::tokenBranches7816[] = { + {x64Token::NUMBER, 1, 1, 0, NULL,&x64Parser::TokenFunc7817, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7822(x64Operand &operand, int tokenPos) { operand.operandCoding = 665; operand.values[22] = new Coding[2]; @@ -32126,37 +32151,37 @@ void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7824_16[] = { +Coding x64Parser::tokenCoding7828_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_17[] = { +Coding x64Parser::tokenCoding7828_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_18[] = { +Coding x64Parser::tokenCoding7828_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7824_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 5 }, +Coding x64Parser::tokenCoding7828_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) { operand.operandCoding = 668; - operand.values[16] = tokenCoding7824_16; - operand.values[17] = tokenCoding7824_17; - operand.values[18] = tokenCoding7824_18; - operand.values[19] = tokenCoding7824_19; + operand.values[16] = tokenCoding7828_16; + operand.values[17] = tokenCoding7828_17; + operand.values[18] = tokenCoding7828_18; + operand.values[19] = tokenCoding7828_19; } -x64Token x64Parser::tokenBranches7817[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7818, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7824, }, +x64Token x64Parser::tokenBranches7821[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7822, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7828, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7824(x64Operand &operand, int tokenPos) { operand.operandCoding = 666; operand.values[22] = new Coding[2]; @@ -32170,39 +32195,83 @@ void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -Coding x64Parser::tokenCoding7826_16[] = { +Coding x64Parser::tokenCoding7830_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_17[] = { +Coding x64Parser::tokenCoding7830_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_18[] = { +Coding x64Parser::tokenCoding7830_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding7826_19[] = { - { CODING_NAME("rm") Coding::stateFunc, 6 }, +Coding x64Parser::tokenCoding7830_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; +void x64Parser::TokenFunc7830(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; + operand.values[16] = tokenCoding7830_16; + operand.values[17] = tokenCoding7830_17; + operand.values[18] = tokenCoding7830_18; + operand.values[19] = tokenCoding7830_19; +} +x64Token x64Parser::tokenBranches7823[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7824, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7830, }, + {x64Token::EOT } +}; void x64Parser::TokenFunc7826(x64Operand &operand, int tokenPos) { - operand.operandCoding = 668; - operand.values[16] = tokenCoding7826_16; - operand.values[17] = tokenCoding7826_17; - operand.values[18] = tokenCoding7826_18; - operand.values[19] = tokenCoding7826_19; + operand.operandCoding = 667; + operand.values[22] = new Coding[2]; + CleanupValues.push_back(operand.values[22]); + operand.values[22]->type = Coding::number; + operand.values[22]->val = operands.size(); + operand.values[22]->bits = 0; + operand.values[22]->field = 0; + operand.values[22]->unary = 0; + operand.values[22]->binary = 0; + operand.values[22][1].type = Coding::eot; + operands.push_back(numeric); } -x64Token x64Parser::tokenBranches7819[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7820, }, - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7826, }, +Coding x64Parser::tokenCoding7832_16[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_17[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_18[] = { + { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding7832_19[] = { + { CODING_NAME("rm") Coding::stateFunc, 6 }, + { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc7832(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 669; + operand.values[16] = tokenCoding7832_16; + operand.values[17] = tokenCoding7832_17; + operand.values[18] = tokenCoding7832_18; + operand.values[19] = tokenCoding7832_19; +} +x64Token x64Parser::tokenBranches7825[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc7826, }, + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc7832, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) { - operand.operandCoding = 660; + operand.operandCoding = 661; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32213,9 +32282,9 @@ void x64Parser::TokenFunc7807(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) { - operand.operandCoding = 661; + operand.operandCoding = 662; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32226,9 +32295,9 @@ void x64Parser::TokenFunc7808(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7815(x64Operand &operand, int tokenPos) { - operand.operandCoding = 662; + operand.operandCoding = 663; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -32239,9 +32308,9 @@ void x64Parser::TokenFunc7809(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7818(x64Operand &operand, int tokenPos) { - operand.operandCoding = 664; + operand.operandCoding = 665; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32253,9 +32322,9 @@ void x64Parser::TokenFunc7812(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7819(x64Operand &operand, int tokenPos) { - operand.operandCoding = 665; + operand.operandCoding = 666; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32267,9 +32336,9 @@ void x64Parser::TokenFunc7813(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7820(x64Operand &operand, int tokenPos) { - operand.operandCoding = 666; + operand.operandCoding = 667; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32281,17 +32350,17 @@ void x64Parser::TokenFunc7814(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7827(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 669; -} -void x64Parser::TokenFunc7828(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7833(x64Operand &operand, int tokenPos) { operand.operandCoding = 670; } -void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7834(x64Operand &operand, int tokenPos) { operand.operandCoding = 671; +} +void x64Parser::TokenFunc7835(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 672; operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); operand.values[2]->type = Coding::reg; @@ -32302,25 +32371,25 @@ void x64Parser::TokenFunc7829(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7806[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7807, }, - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7808, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7809, }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7810 }, - {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7812, }, - {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7813, }, - {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7814, }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7815 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7817 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7819 }, - {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7827, }, - {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7828, }, - {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7829, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) +x64Token x64Parser::tokenBranches7812[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc7813, }, + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc7814, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc7815, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches7816 }, + {x64Token::NUMBER, 6, 1, 0, NULL,&x64Parser::TokenFunc7818, }, + {x64Token::NUMBER, 7, 1, 0, NULL,&x64Parser::TokenFunc7819, }, + {x64Token::NUMBER, 8, 1, 0, NULL,&x64Parser::TokenFunc7820, }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7821 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7823 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7825 }, + {x64Token::REGISTER, 97, 1, 0, NULL,&x64Parser::TokenFunc7833, }, + {x64Token::REGISTER, 98, 1, 0, NULL,&x64Parser::TokenFunc7834, }, + {x64Token::REGISTERCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc7835, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc7849(x64Operand &operand, int tokenPos) { - operand.operandCoding = 672; + operand.operandCoding = 673; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32332,18 +32401,18 @@ void x64Parser::TokenFunc7843(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7844(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7850(x64Operand &operand, int tokenPos) { - operand.operandCoding = 673; + operand.operandCoding = 674; } -x64Token x64Parser::tokenBranches7842[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7843, }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7844, }, +x64Token x64Parser::tokenBranches7848[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7849, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7850, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7852(x64Operand &operand, int tokenPos) { - operand.operandCoding = 674; + operand.operandCoding = 675; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -32355,87 +32424,87 @@ void x64Parser::TokenFunc7846(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -void x64Parser::TokenFunc7847(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7853(x64Operand &operand, int tokenPos) { - operand.operandCoding = 675; + operand.operandCoding = 676; } -x64Token x64Parser::tokenBranches7845[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7846, }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7847, }, +x64Token x64Parser::tokenBranches7851[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc7852, }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7853, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7861(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) { - operand.operandCoding = 676; + operand.operandCoding = 677; } -x64Token x64Parser::tokenBranches7860[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7861, }, +x64Token x64Parser::tokenBranches7866[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) { - operand.operandCoding = 678; + operand.operandCoding = 679; } -x64Token x64Parser::tokenBranches7872[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, +x64Token x64Parser::tokenBranches7878[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7859[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7860 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, +x64Token x64Parser::tokenBranches7865[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7858[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7859 }, +x64Token x64Parser::tokenBranches7864[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7857[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7858 }, +x64Token x64Parser::tokenBranches7863[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7864 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7867(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7873(x64Operand &operand, int tokenPos) { - operand.operandCoding = 677; + operand.operandCoding = 678; } -x64Token x64Parser::tokenBranches7866[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7867, }, +x64Token x64Parser::tokenBranches7872[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7873, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7879(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7885(x64Operand &operand, int tokenPos) { - operand.operandCoding = 679; + operand.operandCoding = 680; } -x64Token x64Parser::tokenBranches7878[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7879, }, +x64Token x64Parser::tokenBranches7884[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7885, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) { - operand.operandCoding = 681; + operand.operandCoding = 682; } -x64Token x64Parser::tokenBranches7888[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, +x64Token x64Parser::tokenBranches7894[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7865[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7866 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7878 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, +x64Token x64Parser::tokenBranches7871[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7872 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7884 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7864[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7865 }, +x64Token x64Parser::tokenBranches7870[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7871 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7883(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7889(x64Operand &operand, int tokenPos) { - operand.operandCoding = 680; + operand.operandCoding = 681; } -x64Token x64Parser::tokenBranches7882[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7883, }, +x64Token x64Parser::tokenBranches7888[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7889, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7870(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32447,88 +32516,88 @@ void x64Parser::TokenFunc7864(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7863[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7864, x64Parser::tokenBranches7864 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7882 }, +x64Token x64Parser::tokenBranches7869[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7870, x64Parser::tokenBranches7870 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7888 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7856[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7857 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, +x64Token x64Parser::tokenBranches7862[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7863 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7869 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7895(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) { - operand.operandCoding = 682; + operand.operandCoding = 683; } -x64Token x64Parser::tokenBranches7894[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7895, }, +x64Token x64Parser::tokenBranches7900[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) { - operand.operandCoding = 684; + operand.operandCoding = 685; } -x64Token x64Parser::tokenBranches7906[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, +x64Token x64Parser::tokenBranches7912[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7893[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7894 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, +x64Token x64Parser::tokenBranches7899[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7892[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7893 }, +x64Token x64Parser::tokenBranches7898[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7891[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7892 }, +x64Token x64Parser::tokenBranches7897[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7898 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7901(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7907(x64Operand &operand, int tokenPos) { - operand.operandCoding = 683; + operand.operandCoding = 684; } -x64Token x64Parser::tokenBranches7900[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7901, }, +x64Token x64Parser::tokenBranches7906[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7907, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7913(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7919(x64Operand &operand, int tokenPos) { - operand.operandCoding = 685; + operand.operandCoding = 686; } -x64Token x64Parser::tokenBranches7912[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7913, }, +x64Token x64Parser::tokenBranches7918[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7919, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) { - operand.operandCoding = 687; + operand.operandCoding = 688; } -x64Token x64Parser::tokenBranches7922[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, +x64Token x64Parser::tokenBranches7928[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7899[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7900 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7912 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, +x64Token x64Parser::tokenBranches7905[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7906 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7918 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7898[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7899 }, +x64Token x64Parser::tokenBranches7904[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7905 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7917(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7923(x64Operand &operand, int tokenPos) { - operand.operandCoding = 686; + operand.operandCoding = 687; } -x64Token x64Parser::tokenBranches7916[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7917, }, +x64Token x64Parser::tokenBranches7922[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7923, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7904(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32540,88 +32609,88 @@ void x64Parser::TokenFunc7898(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7897[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7898, x64Parser::tokenBranches7898 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7916 }, +x64Token x64Parser::tokenBranches7903[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7904, x64Parser::tokenBranches7904 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7922 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7890[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7891 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, +x64Token x64Parser::tokenBranches7896[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7897 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7903 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7929(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) { - operand.operandCoding = 688; + operand.operandCoding = 689; } -x64Token x64Parser::tokenBranches7928[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7929, }, +x64Token x64Parser::tokenBranches7934[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) { - operand.operandCoding = 690; + operand.operandCoding = 691; } -x64Token x64Parser::tokenBranches7940[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, +x64Token x64Parser::tokenBranches7946[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7927[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7928 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, +x64Token x64Parser::tokenBranches7933[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7926[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7927 }, +x64Token x64Parser::tokenBranches7932[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7925[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7926 }, +x64Token x64Parser::tokenBranches7931[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7932 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7935(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7941(x64Operand &operand, int tokenPos) { - operand.operandCoding = 689; + operand.operandCoding = 690; } -x64Token x64Parser::tokenBranches7934[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7935, }, +x64Token x64Parser::tokenBranches7940[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7941, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7947(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7953(x64Operand &operand, int tokenPos) { - operand.operandCoding = 691; + operand.operandCoding = 692; } -x64Token x64Parser::tokenBranches7946[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7947, }, +x64Token x64Parser::tokenBranches7952[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7953, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) { - operand.operandCoding = 693; + operand.operandCoding = 694; } -x64Token x64Parser::tokenBranches7956[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, +x64Token x64Parser::tokenBranches7962[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7933[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7934 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7946 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, +x64Token x64Parser::tokenBranches7939[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches7940 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7952 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7932[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7933 }, +x64Token x64Parser::tokenBranches7938[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7939 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7951(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7957(x64Operand &operand, int tokenPos) { - operand.operandCoding = 692; + operand.operandCoding = 693; } -x64Token x64Parser::tokenBranches7950[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7951, }, +x64Token x64Parser::tokenBranches7956[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7957, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7938(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32633,70 +32702,70 @@ void x64Parser::TokenFunc7932(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7931[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7932, x64Parser::tokenBranches7932 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7950 }, +x64Token x64Parser::tokenBranches7937[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7938, x64Parser::tokenBranches7938 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7956 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7924[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7925 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, +x64Token x64Parser::tokenBranches7930[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7931 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7937 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7963(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) { - operand.operandCoding = 694; + operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7962[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7963, }, +x64Token x64Parser::tokenBranches7968[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7961[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7962 }, +x64Token x64Parser::tokenBranches7967[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7960[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7961 }, +x64Token x64Parser::tokenBranches7966[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7959[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7960 }, +x64Token x64Parser::tokenBranches7965[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7966 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7969(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7975(x64Operand &operand, int tokenPos) { - operand.operandCoding = 695; + operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7968[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7969, }, +x64Token x64Parser::tokenBranches7974[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7975, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7985(x64Operand &operand, int tokenPos) { - operand.operandCoding = 695; + operand.operandCoding = 696; } -x64Token x64Parser::tokenBranches7978[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, +x64Token x64Parser::tokenBranches7984[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7985, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7967[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7968 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, +x64Token x64Parser::tokenBranches7973[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches7974 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7984 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7966[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7967 }, +x64Token x64Parser::tokenBranches7972[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches7973 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7973(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7979(x64Operand &operand, int tokenPos) { - operand.operandCoding = 694; + operand.operandCoding = 695; } -x64Token x64Parser::tokenBranches7972[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7973, }, +x64Token x64Parser::tokenBranches7978[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc7979, }, {x64Token::EOT } }; -void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7972(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32708,132 +32777,132 @@ void x64Parser::TokenFunc7966(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches7965[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7966, x64Parser::tokenBranches7966 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7972 }, +x64Token x64Parser::tokenBranches7971[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc7972, x64Parser::tokenBranches7972 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches7978 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7958[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7959 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, +x64Token x64Parser::tokenBranches7964[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches7965 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches7971 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches7855[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7856 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7890 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7924 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7958 }, +x64Token x64Parser::tokenBranches7861[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches7862 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches7896 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches7930 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches7964 }, {x64Token::EOT } }; -void x64Parser::TokenFunc7984(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc7990(x64Operand &operand, int tokenPos) { - operand.operandCoding = 696; + operand.operandCoding = 697; } -x64Token x64Parser::tokenBranches7983[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7984, }, +x64Token x64Parser::tokenBranches7989[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc7990, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8024_16[] = { +Coding x64Parser::tokenCoding8030_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_17[] = { +Coding x64Parser::tokenCoding8030_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_18[] = { +Coding x64Parser::tokenCoding8030_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8024_19[] = { +Coding x64Parser::tokenCoding8030_19[] = { { CODING_NAME("reg") Coding::stateFunc, 4 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8024(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8030(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8024_16; - operand.values[17] = tokenCoding8024_17; - operand.values[18] = tokenCoding8024_18; - operand.values[19] = tokenCoding8024_19; + operand.values[16] = tokenCoding8030_16; + operand.values[17] = tokenCoding8030_17; + operand.values[18] = tokenCoding8030_18; + operand.values[19] = tokenCoding8030_19; } -x64Token x64Parser::tokenBranches8023[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8024, }, +x64Token x64Parser::tokenBranches8029[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8030, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8034(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) { - operand.operandCoding = 697; + operand.operandCoding = 698; } -x64Token x64Parser::tokenBranches8033[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8034, }, +x64Token x64Parser::tokenBranches8039[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) { - operand.operandCoding = 699; + operand.operandCoding = 700; } -x64Token x64Parser::tokenBranches8045[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, +x64Token x64Parser::tokenBranches8051[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8032[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8033 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, +x64Token x64Parser::tokenBranches8038[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8031[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8032 }, +x64Token x64Parser::tokenBranches8037[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8030[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8031 }, +x64Token x64Parser::tokenBranches8036[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8037 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8040(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8046(x64Operand &operand, int tokenPos) { - operand.operandCoding = 698; + operand.operandCoding = 699; } -x64Token x64Parser::tokenBranches8039[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8040, }, +x64Token x64Parser::tokenBranches8045[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8046, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8052(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8058(x64Operand &operand, int tokenPos) { - operand.operandCoding = 700; + operand.operandCoding = 701; } -x64Token x64Parser::tokenBranches8051[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8052, }, +x64Token x64Parser::tokenBranches8057[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8058, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) { - operand.operandCoding = 702; + operand.operandCoding = 703; } -x64Token x64Parser::tokenBranches8061[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, +x64Token x64Parser::tokenBranches8067[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8038[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8039 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8051 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, +x64Token x64Parser::tokenBranches8044[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8045 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8057 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8037[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8038 }, +x64Token x64Parser::tokenBranches8043[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8044 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8056(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8062(x64Operand &operand, int tokenPos) { - operand.operandCoding = 701; + operand.operandCoding = 702; } -x64Token x64Parser::tokenBranches8055[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8056, }, +x64Token x64Parser::tokenBranches8061[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8062, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8043(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32845,88 +32914,88 @@ void x64Parser::TokenFunc8037(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8036[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8037, x64Parser::tokenBranches8037 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8055 }, +x64Token x64Parser::tokenBranches8042[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8043, x64Parser::tokenBranches8043 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8061 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8029[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8030 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, +x64Token x64Parser::tokenBranches8035[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8036 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8042 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8068(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) { - operand.operandCoding = 703; + operand.operandCoding = 704; } -x64Token x64Parser::tokenBranches8067[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8068, }, +x64Token x64Parser::tokenBranches8073[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) { - operand.operandCoding = 705; + operand.operandCoding = 706; } -x64Token x64Parser::tokenBranches8079[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, +x64Token x64Parser::tokenBranches8085[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8066[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8067 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, +x64Token x64Parser::tokenBranches8072[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8065[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8066 }, +x64Token x64Parser::tokenBranches8071[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8064[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8065 }, +x64Token x64Parser::tokenBranches8070[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8071 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8074(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8080(x64Operand &operand, int tokenPos) { - operand.operandCoding = 704; + operand.operandCoding = 705; } -x64Token x64Parser::tokenBranches8073[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8074, }, +x64Token x64Parser::tokenBranches8079[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8080, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8086(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8092(x64Operand &operand, int tokenPos) { - operand.operandCoding = 706; + operand.operandCoding = 707; } -x64Token x64Parser::tokenBranches8085[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8086, }, +x64Token x64Parser::tokenBranches8091[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8092, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) { - operand.operandCoding = 708; + operand.operandCoding = 709; } -x64Token x64Parser::tokenBranches8095[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, +x64Token x64Parser::tokenBranches8101[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8072[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8073 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8085 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, +x64Token x64Parser::tokenBranches8078[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8079 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8091 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8071[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8072 }, +x64Token x64Parser::tokenBranches8077[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8078 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8090(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8096(x64Operand &operand, int tokenPos) { - operand.operandCoding = 707; + operand.operandCoding = 708; } -x64Token x64Parser::tokenBranches8089[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8090, }, +x64Token x64Parser::tokenBranches8095[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8096, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8077(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -32938,88 +33007,88 @@ void x64Parser::TokenFunc8071(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8070[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8071, x64Parser::tokenBranches8071 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8089 }, +x64Token x64Parser::tokenBranches8076[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8077, x64Parser::tokenBranches8077 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8095 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8063[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8064 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, +x64Token x64Parser::tokenBranches8069[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8070 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8076 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8102(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) { - operand.operandCoding = 709; + operand.operandCoding = 710; } -x64Token x64Parser::tokenBranches8101[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8102, }, +x64Token x64Parser::tokenBranches8107[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) { - operand.operandCoding = 711; + operand.operandCoding = 712; } -x64Token x64Parser::tokenBranches8113[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, +x64Token x64Parser::tokenBranches8119[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8100[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8101 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, +x64Token x64Parser::tokenBranches8106[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8099[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8100 }, +x64Token x64Parser::tokenBranches8105[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8098[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8099 }, +x64Token x64Parser::tokenBranches8104[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8105 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8108(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8114(x64Operand &operand, int tokenPos) { - operand.operandCoding = 710; + operand.operandCoding = 711; } -x64Token x64Parser::tokenBranches8107[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8108, }, +x64Token x64Parser::tokenBranches8113[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8114, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8120(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8126(x64Operand &operand, int tokenPos) { - operand.operandCoding = 712; + operand.operandCoding = 713; } -x64Token x64Parser::tokenBranches8119[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8120, }, +x64Token x64Parser::tokenBranches8125[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8126, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) { - operand.operandCoding = 714; + operand.operandCoding = 715; } -x64Token x64Parser::tokenBranches8129[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, +x64Token x64Parser::tokenBranches8135[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8106[] = { - {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8107 }, - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8119 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, +x64Token x64Parser::tokenBranches8112[] = { + {x64Token::REGISTER, 61, 0, 0, NULL, NULL, x64Parser::tokenBranches8113 }, + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8125 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8105[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8106 }, +x64Token x64Parser::tokenBranches8111[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8112 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8124(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8130(x64Operand &operand, int tokenPos) { - operand.operandCoding = 713; + operand.operandCoding = 714; } -x64Token x64Parser::tokenBranches8123[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8124, }, +x64Token x64Parser::tokenBranches8129[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8130, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8111(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -33031,70 +33100,70 @@ void x64Parser::TokenFunc8105(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8104[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8105, x64Parser::tokenBranches8105 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8123 }, +x64Token x64Parser::tokenBranches8110[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8111, x64Parser::tokenBranches8111 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8129 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8097[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8098 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, +x64Token x64Parser::tokenBranches8103[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8104 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8110 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8136(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) { - operand.operandCoding = 715; + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8135[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8136, }, +x64Token x64Parser::tokenBranches8141[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8134[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8135 }, +x64Token x64Parser::tokenBranches8140[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8133[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8134 }, +x64Token x64Parser::tokenBranches8139[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8132[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8133 }, +x64Token x64Parser::tokenBranches8138[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8139 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8142(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8148(x64Operand &operand, int tokenPos) { - operand.operandCoding = 716; + operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8141[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8142, }, +x64Token x64Parser::tokenBranches8147[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8148, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8158(x64Operand &operand, int tokenPos) { - operand.operandCoding = 716; + operand.operandCoding = 717; } -x64Token x64Parser::tokenBranches8151[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, +x64Token x64Parser::tokenBranches8157[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8158, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8140[] = { - {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8141 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, +x64Token x64Parser::tokenBranches8146[] = { + {x64Token::REGISTER, 62, 0, 0, NULL, NULL, x64Parser::tokenBranches8147 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8157 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8139[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8140 }, +x64Token x64Parser::tokenBranches8145[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8146 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8146(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8152(x64Operand &operand, int tokenPos) { - operand.operandCoding = 715; + operand.operandCoding = 716; } -x64Token x64Parser::tokenBranches8145[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8146, }, +x64Token x64Parser::tokenBranches8151[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8152, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8145(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -33106,115 +33175,115 @@ void x64Parser::TokenFunc8139(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8138[] = { - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8139, x64Parser::tokenBranches8139 }, - {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8145 }, +x64Token x64Parser::tokenBranches8144[] = { + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8145, x64Parser::tokenBranches8145 }, + {x64Token::REGISTER, 63, 0, 0, NULL, NULL, x64Parser::tokenBranches8151 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8131[] = { - {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8132 }, - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, +x64Token x64Parser::tokenBranches8137[] = { + {x64Token::REGISTER, 93, 0, 0, NULL, NULL, x64Parser::tokenBranches8138 }, + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8144 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8028[] = { - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8029 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8063 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8097 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8131 }, +x64Token x64Parser::tokenBranches8034[] = { + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8035 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8069 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8103 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8137 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8157(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8163(x64Operand &operand, int tokenPos) { - operand.operandCoding = 717; + operand.operandCoding = 718; } -x64Token x64Parser::tokenBranches8156[] = { - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8157, }, +x64Token x64Parser::tokenBranches8162[] = { + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8163, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8159_16[] = { +Coding x64Parser::tokenCoding8165_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_17[] = { +Coding x64Parser::tokenCoding8165_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_18[] = { +Coding x64Parser::tokenCoding8165_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8159_19[] = { +Coding x64Parser::tokenCoding8165_19[] = { { CODING_NAME("reg") Coding::stateFunc, 4 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8159(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8165(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8159_16; - operand.values[17] = tokenCoding8159_17; - operand.values[18] = tokenCoding8159_18; - operand.values[19] = tokenCoding8159_19; + operand.values[16] = tokenCoding8165_16; + operand.values[17] = tokenCoding8165_17; + operand.values[18] = tokenCoding8165_18; + operand.values[19] = tokenCoding8165_19; } -Coding x64Parser::tokenCoding8160_16[] = { +Coding x64Parser::tokenCoding8166_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_17[] = { +Coding x64Parser::tokenCoding8166_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_18[] = { +Coding x64Parser::tokenCoding8166_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8160_19[] = { +Coding x64Parser::tokenCoding8166_19[] = { { CODING_NAME("reg") Coding::stateFunc, 5 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8160(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8166(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8160_16; - operand.values[17] = tokenCoding8160_17; - operand.values[18] = tokenCoding8160_18; - operand.values[19] = tokenCoding8160_19; + operand.values[16] = tokenCoding8166_16; + operand.values[17] = tokenCoding8166_17; + operand.values[18] = tokenCoding8166_18; + operand.values[19] = tokenCoding8166_19; } -Coding x64Parser::tokenCoding8161_16[] = { +Coding x64Parser::tokenCoding8167_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_17[] = { +Coding x64Parser::tokenCoding8167_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_18[] = { +Coding x64Parser::tokenCoding8167_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8161_19[] = { +Coding x64Parser::tokenCoding8167_19[] = { { CODING_NAME("reg") Coding::stateFunc, 6 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8161(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8167(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8161_16; - operand.values[17] = tokenCoding8161_17; - operand.values[18] = tokenCoding8161_18; - operand.values[19] = tokenCoding8161_19; + operand.values[16] = tokenCoding8167_16; + operand.values[17] = tokenCoding8167_17; + operand.values[18] = tokenCoding8167_18; + operand.values[19] = tokenCoding8167_19; } -x64Token x64Parser::tokenBranches8158[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8159, }, - {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8160, }, - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8161, }, +x64Token x64Parser::tokenBranches8164[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8165, }, + {x64Token::ADDRESSCLASS, 19, 1, 0, NULL,&x64Parser::TokenFunc8166, }, + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8167, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8177(x64Operand &operand, int tokenPos) { - operand.operandCoding = 718; + operand.operandCoding = 719; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33226,21 +33295,21 @@ void x64Parser::TokenFunc8171(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8170[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8171, }, +x64Token x64Parser::tokenBranches8176[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8177, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8169[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8170 }, +x64Token x64Parser::tokenBranches8175[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8176 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8168[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8169 }, +x64Token x64Parser::tokenBranches8174[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8175 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8181(x64Operand &operand, int tokenPos) { - operand.operandCoding = 719; + operand.operandCoding = 720; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33252,21 +33321,21 @@ void x64Parser::TokenFunc8175(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8174[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8175, }, +x64Token x64Parser::tokenBranches8180[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8181, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8173[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8174 }, +x64Token x64Parser::tokenBranches8179[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8180 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8172[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8173 }, +x64Token x64Parser::tokenBranches8178[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8179 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8185(x64Operand &operand, int tokenPos) { - operand.operandCoding = 720; + operand.operandCoding = 721; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33278,21 +33347,21 @@ void x64Parser::TokenFunc8179(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8178[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8179, }, +x64Token x64Parser::tokenBranches8184[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8185, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8177[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8178 }, +x64Token x64Parser::tokenBranches8183[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8176[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8177 }, +x64Token x64Parser::tokenBranches8182[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8183 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8189(x64Operand &operand, int tokenPos) { - operand.operandCoding = 721; + operand.operandCoding = 722; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33304,35 +33373,35 @@ void x64Parser::TokenFunc8183(x64Operand &operand, int tokenPos) operand.values[22][1].type = Coding::eot; operands.push_back(numeric); } -x64Token x64Parser::tokenBranches8182[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8183, }, +x64Token x64Parser::tokenBranches8188[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8189, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8181[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8182 }, +x64Token x64Parser::tokenBranches8187[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8188 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8180[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8181 }, +x64Token x64Parser::tokenBranches8186[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8187 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8187_16[] = { +Coding x64Parser::tokenCoding8193_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_17[] = { +Coding x64Parser::tokenCoding8193_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_18[] = { +Coding x64Parser::tokenCoding8193_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8187_19[] = { +Coding x64Parser::tokenCoding8193_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8193(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33343,32 +33412,32 @@ void x64Parser::TokenFunc8187(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8187_16; - operand.values[17] = tokenCoding8187_17; - operand.values[18] = tokenCoding8187_18; - operand.values[19] = tokenCoding8187_19; + operand.values[16] = tokenCoding8193_16; + operand.values[17] = tokenCoding8193_17; + operand.values[18] = tokenCoding8193_18; + operand.values[19] = tokenCoding8193_19; } -Coding x64Parser::tokenCoding8191_16[] = { +Coding x64Parser::tokenCoding8197_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_17[] = { +Coding x64Parser::tokenCoding8197_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_23[] = { +Coding x64Parser::tokenCoding8197_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_18[] = { +Coding x64Parser::tokenCoding8197_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8191_19[] = { +Coding x64Parser::tokenCoding8197_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8197(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33379,43 +33448,43 @@ void x64Parser::TokenFunc8191(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8191_16; - operand.values[17] = tokenCoding8191_17; - operand.values[23] = tokenCoding8191_23; - operand.values[18] = tokenCoding8191_18; - operand.values[19] = tokenCoding8191_19; + operand.values[16] = tokenCoding8197_16; + operand.values[17] = tokenCoding8197_17; + operand.values[23] = tokenCoding8197_23; + operand.values[18] = tokenCoding8197_18; + operand.values[19] = tokenCoding8197_19; } -x64Token x64Parser::tokenBranches8186[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8187, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8191, }, +x64Token x64Parser::tokenBranches8192[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8193, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8197, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8185[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, +x64Token x64Parser::tokenBranches8191[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8192 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8184[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8185 }, +x64Token x64Parser::tokenBranches8190[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8191 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8195_16[] = { +Coding x64Parser::tokenCoding8201_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_17[] = { +Coding x64Parser::tokenCoding8201_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_18[] = { +Coding x64Parser::tokenCoding8201_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8195_19[] = { +Coding x64Parser::tokenCoding8201_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8201(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33426,41 +33495,41 @@ void x64Parser::TokenFunc8195(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8195_16; - operand.values[17] = tokenCoding8195_17; - operand.values[18] = tokenCoding8195_18; - operand.values[19] = tokenCoding8195_19; + operand.values[16] = tokenCoding8201_16; + operand.values[17] = tokenCoding8201_17; + operand.values[18] = tokenCoding8201_18; + operand.values[19] = tokenCoding8201_19; } -x64Token x64Parser::tokenBranches8194[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8195, }, +x64Token x64Parser::tokenBranches8200[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8201, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8193[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8194 }, +x64Token x64Parser::tokenBranches8199[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8200 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8192[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8193 }, +x64Token x64Parser::tokenBranches8198[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8199 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8199_16[] = { +Coding x64Parser::tokenCoding8205_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_17[] = { +Coding x64Parser::tokenCoding8205_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_18[] = { +Coding x64Parser::tokenCoding8205_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8199_19[] = { +Coding x64Parser::tokenCoding8205_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8205(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33471,41 +33540,41 @@ void x64Parser::TokenFunc8199(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8199_16; - operand.values[17] = tokenCoding8199_17; - operand.values[18] = tokenCoding8199_18; - operand.values[19] = tokenCoding8199_19; + operand.values[16] = tokenCoding8205_16; + operand.values[17] = tokenCoding8205_17; + operand.values[18] = tokenCoding8205_18; + operand.values[19] = tokenCoding8205_19; } -x64Token x64Parser::tokenBranches8198[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8199, }, +x64Token x64Parser::tokenBranches8204[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8205, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8197[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8198 }, +x64Token x64Parser::tokenBranches8203[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8196[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8197 }, +x64Token x64Parser::tokenBranches8202[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8203 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8203_16[] = { +Coding x64Parser::tokenCoding8209_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_17[] = { +Coding x64Parser::tokenCoding8209_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_18[] = { +Coding x64Parser::tokenCoding8209_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8203_19[] = { +Coding x64Parser::tokenCoding8209_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33516,40 +33585,40 @@ void x64Parser::TokenFunc8203(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8203_16; - operand.values[17] = tokenCoding8203_17; - operand.values[18] = tokenCoding8203_18; - operand.values[19] = tokenCoding8203_19; + operand.values[16] = tokenCoding8209_16; + operand.values[17] = tokenCoding8209_17; + operand.values[18] = tokenCoding8209_18; + operand.values[19] = tokenCoding8209_19; } -x64Token x64Parser::tokenBranches8202[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8203, }, +x64Token x64Parser::tokenBranches8208[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8209, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8201[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8202 }, +x64Token x64Parser::tokenBranches8207[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8200[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8201 }, +x64Token x64Parser::tokenBranches8206[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8248_16[] = { +Coding x64Parser::tokenCoding8254_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_17[] = { +Coding x64Parser::tokenCoding8254_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_18[] = { +Coding x64Parser::tokenCoding8254_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8248_19[] = { +Coding x64Parser::tokenCoding8254_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8254(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -33562,32 +33631,32 @@ void x64Parser::TokenFunc8248(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8248_16; - operand.values[17] = tokenCoding8248_17; - operand.values[18] = tokenCoding8248_18; - operand.values[19] = tokenCoding8248_19; + operand.values[16] = tokenCoding8254_16; + operand.values[17] = tokenCoding8254_17; + operand.values[18] = tokenCoding8254_18; + operand.values[19] = tokenCoding8254_19; } -x64Token x64Parser::tokenBranches8247[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8248, }, +x64Token x64Parser::tokenBranches8253[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8254, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8206_16[] = { +Coding x64Parser::tokenCoding8212_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_17[] = { +Coding x64Parser::tokenCoding8212_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_18[] = { +Coding x64Parser::tokenCoding8212_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8206_19[] = { +Coding x64Parser::tokenCoding8212_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33598,32 +33667,32 @@ void x64Parser::TokenFunc8206(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8206_16; - operand.values[17] = tokenCoding8206_17; - operand.values[18] = tokenCoding8206_18; - operand.values[19] = tokenCoding8206_19; + operand.values[16] = tokenCoding8212_16; + operand.values[17] = tokenCoding8212_17; + operand.values[18] = tokenCoding8212_18; + operand.values[19] = tokenCoding8212_19; } -Coding x64Parser::tokenCoding8212_16[] = { +Coding x64Parser::tokenCoding8218_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_17[] = { +Coding x64Parser::tokenCoding8218_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_23[] = { +Coding x64Parser::tokenCoding8218_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_18[] = { +Coding x64Parser::tokenCoding8218_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8212_19[] = { +Coding x64Parser::tokenCoding8218_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33634,43 +33703,43 @@ void x64Parser::TokenFunc8212(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8212_16; - operand.values[17] = tokenCoding8212_17; - operand.values[23] = tokenCoding8212_23; - operand.values[18] = tokenCoding8212_18; - operand.values[19] = tokenCoding8212_19; + operand.values[16] = tokenCoding8218_16; + operand.values[17] = tokenCoding8218_17; + operand.values[23] = tokenCoding8218_23; + operand.values[18] = tokenCoding8218_18; + operand.values[19] = tokenCoding8218_19; } -x64Token x64Parser::tokenBranches8205[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8206, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8212, }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8247 }, +x64Token x64Parser::tokenBranches8211[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8212, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8218, }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8253 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8204[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8205 }, +x64Token x64Parser::tokenBranches8210[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8211 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8209_16[] = { +Coding x64Parser::tokenCoding8215_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_17[] = { +Coding x64Parser::tokenCoding8215_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_23[] = { +Coding x64Parser::tokenCoding8215_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_18[] = { +Coding x64Parser::tokenCoding8215_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8209_19[] = { +Coding x64Parser::tokenCoding8215_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33681,33 +33750,33 @@ void x64Parser::TokenFunc8209(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8209_16; - operand.values[17] = tokenCoding8209_17; - operand.values[23] = tokenCoding8209_23; - operand.values[18] = tokenCoding8209_18; - operand.values[19] = tokenCoding8209_19; + operand.values[16] = tokenCoding8215_16; + operand.values[17] = tokenCoding8215_17; + operand.values[23] = tokenCoding8215_23; + operand.values[18] = tokenCoding8215_18; + operand.values[19] = tokenCoding8215_19; } -Coding x64Parser::tokenCoding8215_16[] = { +Coding x64Parser::tokenCoding8221_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_17[] = { +Coding x64Parser::tokenCoding8221_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_23[] = { +Coding x64Parser::tokenCoding8221_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_18[] = { +Coding x64Parser::tokenCoding8221_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8215_19[] = { +Coding x64Parser::tokenCoding8221_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33718,41 +33787,41 @@ void x64Parser::TokenFunc8215(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8215_16; - operand.values[17] = tokenCoding8215_17; - operand.values[23] = tokenCoding8215_23; - operand.values[18] = tokenCoding8215_18; - operand.values[19] = tokenCoding8215_19; + operand.values[16] = tokenCoding8221_16; + operand.values[17] = tokenCoding8221_17; + operand.values[23] = tokenCoding8221_23; + operand.values[18] = tokenCoding8221_18; + operand.values[19] = tokenCoding8221_19; } -x64Token x64Parser::tokenBranches8208[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8209, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8215, }, +x64Token x64Parser::tokenBranches8214[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8215, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8221, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8207[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8208 }, +x64Token x64Parser::tokenBranches8213[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8214 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8252_16[] = { +Coding x64Parser::tokenCoding8258_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_17[] = { +Coding x64Parser::tokenCoding8258_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_18[] = { +Coding x64Parser::tokenCoding8258_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8252_19[] = { +Coding x64Parser::tokenCoding8258_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8258(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33763,33 +33832,33 @@ void x64Parser::TokenFunc8252(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8252_16; - operand.values[17] = tokenCoding8252_17; - operand.values[18] = tokenCoding8252_18; - operand.values[19] = tokenCoding8252_19; + operand.values[16] = tokenCoding8258_16; + operand.values[17] = tokenCoding8258_17; + operand.values[18] = tokenCoding8258_18; + operand.values[19] = tokenCoding8258_19; } -x64Token x64Parser::tokenBranches8251[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8252, }, +x64Token x64Parser::tokenBranches8257[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8258, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8218_16[] = { +Coding x64Parser::tokenCoding8224_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_17[] = { +Coding x64Parser::tokenCoding8224_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_18[] = { +Coding x64Parser::tokenCoding8224_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8218_19[] = { +Coding x64Parser::tokenCoding8224_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33800,40 +33869,40 @@ void x64Parser::TokenFunc8218(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8218_16; - operand.values[17] = tokenCoding8218_17; - operand.values[18] = tokenCoding8218_18; - operand.values[19] = tokenCoding8218_19; + operand.values[16] = tokenCoding8224_16; + operand.values[17] = tokenCoding8224_17; + operand.values[18] = tokenCoding8224_18; + operand.values[19] = tokenCoding8224_19; } -x64Token x64Parser::tokenBranches8217[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8218, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8251 }, +x64Token x64Parser::tokenBranches8223[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8224, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8257 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8216[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8217 }, +x64Token x64Parser::tokenBranches8222[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8256_16[] = { +Coding x64Parser::tokenCoding8262_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_17[] = { +Coding x64Parser::tokenCoding8262_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_18[] = { +Coding x64Parser::tokenCoding8262_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8256_19[] = { +Coding x64Parser::tokenCoding8262_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8262(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33844,33 +33913,33 @@ void x64Parser::TokenFunc8256(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8256_16; - operand.values[17] = tokenCoding8256_17; - operand.values[18] = tokenCoding8256_18; - operand.values[19] = tokenCoding8256_19; + operand.values[16] = tokenCoding8262_16; + operand.values[17] = tokenCoding8262_17; + operand.values[18] = tokenCoding8262_18; + operand.values[19] = tokenCoding8262_19; } -x64Token x64Parser::tokenBranches8255[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8256, }, +x64Token x64Parser::tokenBranches8261[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8262, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8221_16[] = { +Coding x64Parser::tokenCoding8227_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_17[] = { +Coding x64Parser::tokenCoding8227_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_18[] = { +Coding x64Parser::tokenCoding8227_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8221_19[] = { +Coding x64Parser::tokenCoding8227_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8227(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33881,40 +33950,40 @@ void x64Parser::TokenFunc8221(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8221_16; - operand.values[17] = tokenCoding8221_17; - operand.values[18] = tokenCoding8221_18; - operand.values[19] = tokenCoding8221_19; + operand.values[16] = tokenCoding8227_16; + operand.values[17] = tokenCoding8227_17; + operand.values[18] = tokenCoding8227_18; + operand.values[19] = tokenCoding8227_19; } -x64Token x64Parser::tokenBranches8220[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8221, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8255 }, +x64Token x64Parser::tokenBranches8226[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8227, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8261 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8219[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8220 }, +x64Token x64Parser::tokenBranches8225[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8260_16[] = { +Coding x64Parser::tokenCoding8266_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_17[] = { +Coding x64Parser::tokenCoding8266_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_18[] = { +Coding x64Parser::tokenCoding8266_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8260_19[] = { +Coding x64Parser::tokenCoding8266_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8266(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -33925,33 +33994,33 @@ void x64Parser::TokenFunc8260(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8260_16; - operand.values[17] = tokenCoding8260_17; - operand.values[18] = tokenCoding8260_18; - operand.values[19] = tokenCoding8260_19; + operand.values[16] = tokenCoding8266_16; + operand.values[17] = tokenCoding8266_17; + operand.values[18] = tokenCoding8266_18; + operand.values[19] = tokenCoding8266_19; } -x64Token x64Parser::tokenBranches8259[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8260, }, +x64Token x64Parser::tokenBranches8265[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8266, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8224_16[] = { +Coding x64Parser::tokenCoding8230_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_17[] = { +Coding x64Parser::tokenCoding8230_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_18[] = { +Coding x64Parser::tokenCoding8230_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8224_19[] = { +Coding x64Parser::tokenCoding8230_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8230(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -33962,220 +34031,220 @@ void x64Parser::TokenFunc8224(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8224_16; - operand.values[17] = tokenCoding8224_17; - operand.values[18] = tokenCoding8224_18; - operand.values[19] = tokenCoding8224_19; + operand.values[16] = tokenCoding8230_16; + operand.values[17] = tokenCoding8230_17; + operand.values[18] = tokenCoding8230_18; + operand.values[19] = tokenCoding8230_19; } -x64Token x64Parser::tokenBranches8223[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8224, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8259 }, +x64Token x64Parser::tokenBranches8229[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8230, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8265 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8222[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8223 }, +x64Token x64Parser::tokenBranches8228[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8229 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8228_16[] = { +Coding x64Parser::tokenCoding8234_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_17[] = { +Coding x64Parser::tokenCoding8234_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_18[] = { +Coding x64Parser::tokenCoding8234_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8228_19[] = { +Coding x64Parser::tokenCoding8234_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8228(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8234(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8228_16; - operand.values[17] = tokenCoding8228_17; - operand.values[18] = tokenCoding8228_18; - operand.values[19] = tokenCoding8228_19; + operand.values[16] = tokenCoding8234_16; + operand.values[17] = tokenCoding8234_17; + operand.values[18] = tokenCoding8234_18; + operand.values[19] = tokenCoding8234_19; } -x64Token x64Parser::tokenBranches8227[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8228, }, +x64Token x64Parser::tokenBranches8233[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8234, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8226[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8227 }, +x64Token x64Parser::tokenBranches8232[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8233 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8225[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8226 }, +x64Token x64Parser::tokenBranches8231[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8232 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8232_16[] = { +Coding x64Parser::tokenCoding8238_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_17[] = { +Coding x64Parser::tokenCoding8238_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_23[] = { +Coding x64Parser::tokenCoding8238_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_18[] = { +Coding x64Parser::tokenCoding8238_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8232_19[] = { +Coding x64Parser::tokenCoding8238_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 132, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8232(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8238(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8232_16; - operand.values[17] = tokenCoding8232_17; - operand.values[23] = tokenCoding8232_23; - operand.values[18] = tokenCoding8232_18; - operand.values[19] = tokenCoding8232_19; + operand.values[16] = tokenCoding8238_16; + operand.values[17] = tokenCoding8238_17; + operand.values[23] = tokenCoding8238_23; + operand.values[18] = tokenCoding8238_18; + operand.values[19] = tokenCoding8238_19; } -x64Token x64Parser::tokenBranches8231[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8232, }, +x64Token x64Parser::tokenBranches8237[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8238, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8230[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8231 }, +x64Token x64Parser::tokenBranches8236[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8237 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8229[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8230 }, +x64Token x64Parser::tokenBranches8235[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8236 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8236_16[] = { +Coding x64Parser::tokenCoding8242_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_17[] = { +Coding x64Parser::tokenCoding8242_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_18[] = { +Coding x64Parser::tokenCoding8242_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8236_19[] = { +Coding x64Parser::tokenCoding8242_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8236(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8242(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8236_16; - operand.values[17] = tokenCoding8236_17; - operand.values[18] = tokenCoding8236_18; - operand.values[19] = tokenCoding8236_19; + operand.values[16] = tokenCoding8242_16; + operand.values[17] = tokenCoding8242_17; + operand.values[18] = tokenCoding8242_18; + operand.values[19] = tokenCoding8242_19; } -x64Token x64Parser::tokenBranches8235[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8236, }, +x64Token x64Parser::tokenBranches8241[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8242, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8234[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8235 }, +x64Token x64Parser::tokenBranches8240[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8241 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8233[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8234 }, +x64Token x64Parser::tokenBranches8239[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8240 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8240_16[] = { +Coding x64Parser::tokenCoding8246_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_17[] = { +Coding x64Parser::tokenCoding8246_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_18[] = { +Coding x64Parser::tokenCoding8246_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8240_19[] = { +Coding x64Parser::tokenCoding8246_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8240(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8246(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8240_16; - operand.values[17] = tokenCoding8240_17; - operand.values[18] = tokenCoding8240_18; - operand.values[19] = tokenCoding8240_19; + operand.values[16] = tokenCoding8246_16; + operand.values[17] = tokenCoding8246_17; + operand.values[18] = tokenCoding8246_18; + operand.values[19] = tokenCoding8246_19; } -x64Token x64Parser::tokenBranches8239[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8240, }, +x64Token x64Parser::tokenBranches8245[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8246, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8238[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8239 }, +x64Token x64Parser::tokenBranches8244[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8245 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8237[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8238 }, +x64Token x64Parser::tokenBranches8243[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8244 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8244_16[] = { +Coding x64Parser::tokenCoding8250_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_17[] = { +Coding x64Parser::tokenCoding8250_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_18[] = { +Coding x64Parser::tokenCoding8250_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8244_19[] = { +Coding x64Parser::tokenCoding8250_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 133, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8244(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8250(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8244_16; - operand.values[17] = tokenCoding8244_17; - operand.values[18] = tokenCoding8244_18; - operand.values[19] = tokenCoding8244_19; + operand.values[16] = tokenCoding8250_16; + operand.values[17] = tokenCoding8250_17; + operand.values[18] = tokenCoding8250_18; + operand.values[19] = tokenCoding8250_19; } -x64Token x64Parser::tokenBranches8243[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8244, }, +x64Token x64Parser::tokenBranches8249[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8250, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8242[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8243 }, +x64Token x64Parser::tokenBranches8248[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8249 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8241[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8242 }, +x64Token x64Parser::tokenBranches8247[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8248 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8265_16[] = { +Coding x64Parser::tokenCoding8271_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_17[] = { +Coding x64Parser::tokenCoding8271_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_18[] = { +Coding x64Parser::tokenCoding8271_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8265_19[] = { +Coding x64Parser::tokenCoding8271_19[] = { { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8271(x64Operand &operand, int tokenPos) { operand.operandCoding = 449; operand.values[22] = new Coding[2]; @@ -34188,47 +34257,47 @@ void x64Parser::TokenFunc8265(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8265_16; - operand.values[17] = tokenCoding8265_17; - operand.values[18] = tokenCoding8265_18; - operand.values[19] = tokenCoding8265_19; + operand.values[16] = tokenCoding8271_16; + operand.values[17] = tokenCoding8271_17; + operand.values[18] = tokenCoding8271_18; + operand.values[19] = tokenCoding8271_19; } -x64Token x64Parser::tokenBranches8264[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8265, }, +x64Token x64Parser::tokenBranches8270[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8271, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8263[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8264 }, +x64Token x64Parser::tokenBranches8269[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8270 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8262[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8263 }, +x64Token x64Parser::tokenBranches8268[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8269 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8261[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8262 }, +x64Token x64Parser::tokenBranches8267[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8270_16[] = { +Coding x64Parser::tokenCoding8276_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_17[] = { +Coding x64Parser::tokenCoding8276_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_18[] = { +Coding x64Parser::tokenCoding8276_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8270_19[] = { +Coding x64Parser::tokenCoding8276_19[] = { { CODING_NAME("omem") Coding::stateFunc, 4 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8276(x64Operand &operand, int tokenPos) { - operand.operandCoding = 512; + operand.operandCoding = 513; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34239,47 +34308,47 @@ void x64Parser::TokenFunc8270(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8270_16; - operand.values[17] = tokenCoding8270_17; - operand.values[18] = tokenCoding8270_18; - operand.values[19] = tokenCoding8270_19; + operand.values[16] = tokenCoding8276_16; + operand.values[17] = tokenCoding8276_17; + operand.values[18] = tokenCoding8276_18; + operand.values[19] = tokenCoding8276_19; } -x64Token x64Parser::tokenBranches8269[] = { - {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8270, }, +x64Token x64Parser::tokenBranches8275[] = { + {x64Token::NUMBER, 4, 1, 0, NULL,&x64Parser::TokenFunc8276, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8268[] = { - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8269 }, +x64Token x64Parser::tokenBranches8274[] = { + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8275 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8267[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8268 }, +x64Token x64Parser::tokenBranches8273[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8274 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8266[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, +x64Token x64Parser::tokenBranches8272[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8275_16[] = { +Coding x64Parser::tokenCoding8281_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_17[] = { +Coding x64Parser::tokenCoding8281_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_18[] = { +Coding x64Parser::tokenCoding8281_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8275_19[] = { +Coding x64Parser::tokenCoding8281_19[] = { { CODING_NAME("omem") Coding::stateFunc, 5 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8281(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34290,47 +34359,47 @@ void x64Parser::TokenFunc8275(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8275_16; - operand.values[17] = tokenCoding8275_17; - operand.values[18] = tokenCoding8275_18; - operand.values[19] = tokenCoding8275_19; + operand.values[16] = tokenCoding8281_16; + operand.values[17] = tokenCoding8281_17; + operand.values[18] = tokenCoding8281_18; + operand.values[19] = tokenCoding8281_19; } -x64Token x64Parser::tokenBranches8274[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8275, }, +x64Token x64Parser::tokenBranches8280[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8281, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8273[] = { - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8274 }, +x64Token x64Parser::tokenBranches8279[] = { + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8280 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8272[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8273 }, +x64Token x64Parser::tokenBranches8278[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8279 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8271[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, +x64Token x64Parser::tokenBranches8277[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8280_16[] = { +Coding x64Parser::tokenCoding8286_16[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_17[] = { +Coding x64Parser::tokenCoding8286_17[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_18[] = { +Coding x64Parser::tokenCoding8286_18[] = { { CODING_NAME("omem") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8280_19[] = { +Coding x64Parser::tokenCoding8286_19[] = { { CODING_NAME("omem") Coding::stateFunc, 6 }, { CODING_NAME("omem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8286(x64Operand &operand, int tokenPos) { - operand.operandCoding = 513; + operand.operandCoding = 514; operand.values[22] = new Coding[2]; CleanupValues.push_back(operand.values[22]); operand.values[22]->type = Coding::number; @@ -34341,28 +34410,28 @@ void x64Parser::TokenFunc8280(x64Operand &operand, int tokenPos) operand.values[22]->binary = 0; operand.values[22][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8280_16; - operand.values[17] = tokenCoding8280_17; - operand.values[18] = tokenCoding8280_18; - operand.values[19] = tokenCoding8280_19; + operand.values[16] = tokenCoding8286_16; + operand.values[17] = tokenCoding8286_17; + operand.values[18] = tokenCoding8286_18; + operand.values[19] = tokenCoding8286_19; } -x64Token x64Parser::tokenBranches8279[] = { - {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8280, }, +x64Token x64Parser::tokenBranches8285[] = { + {x64Token::NUMBER, 5, 1, 0, NULL,&x64Parser::TokenFunc8286, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8278[] = { - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8279 }, +x64Token x64Parser::tokenBranches8284[] = { + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8285 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8277[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8278 }, +x64Token x64Parser::tokenBranches8283[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8284 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8276[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, +x64Token x64Parser::tokenBranches8282[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8283 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8231(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34374,7 +34443,7 @@ void x64Parser::TokenFunc8225(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8235(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34386,7 +34455,7 @@ void x64Parser::TokenFunc8229(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8239(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34398,7 +34467,7 @@ void x64Parser::TokenFunc8233(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8243(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34410,7 +34479,7 @@ void x64Parser::TokenFunc8237(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8247(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34422,105 +34491,105 @@ void x64Parser::TokenFunc8241(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8167[] = { - {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8168 }, - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8172 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8176 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8180 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8184 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8192 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8196 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8200 }, - {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8204 }, - {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8207 }, - {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8216 }, - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8219 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8225, x64Parser::tokenBranches8225 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8229, x64Parser::tokenBranches8229 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8233, x64Parser::tokenBranches8233 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8237, x64Parser::tokenBranches8237 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8241, x64Parser::tokenBranches8241 }, - {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8261 }, - {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8266 }, - {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8271 }, - {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8276 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8283_16[] = { +x64Token x64Parser::tokenBranches8173[] = { + {x64Token::REGISTER, 0, 0, 0, NULL, NULL, x64Parser::tokenBranches8174 }, + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8178 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8182 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8186 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8190 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8198 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8202 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8206 }, + {x64Token::ADDRESSCLASS, 14, 0, 0, NULL, NULL, x64Parser::tokenBranches8210 }, + {x64Token::ADDRESSCLASS, 15, 0, 0, NULL, NULL, x64Parser::tokenBranches8213 }, + {x64Token::ADDRESSCLASS, 17, 0, 0, NULL, NULL, x64Parser::tokenBranches8222 }, + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8225 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8228 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8231, x64Parser::tokenBranches8231 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8235, x64Parser::tokenBranches8235 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8239, x64Parser::tokenBranches8239 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8243, x64Parser::tokenBranches8243 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8247, x64Parser::tokenBranches8247 }, + {x64Token::TOKEN, 11, 0, 0, NULL, NULL, x64Parser::tokenBranches8267 }, + {x64Token::TOKEN, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8272 }, + {x64Token::TOKEN, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8277 }, + {x64Token::TOKEN, 10, 0, 0, NULL, NULL, x64Parser::tokenBranches8282 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8289_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_17[] = { +Coding x64Parser::tokenCoding8289_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_18[] = { +Coding x64Parser::tokenCoding8289_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8283_19[] = { +Coding x64Parser::tokenCoding8289_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8283(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8289(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8283_16; - operand.values[17] = tokenCoding8283_17; - operand.values[18] = tokenCoding8283_18; - operand.values[19] = tokenCoding8283_19; + operand.values[16] = tokenCoding8289_16; + operand.values[17] = tokenCoding8289_17; + operand.values[18] = tokenCoding8289_18; + operand.values[19] = tokenCoding8289_19; } -x64Token x64Parser::tokenBranches8282[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8283, }, +x64Token x64Parser::tokenBranches8288[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8289, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8285_16[] = { +Coding x64Parser::tokenCoding8291_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_17[] = { +Coding x64Parser::tokenCoding8291_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_18[] = { +Coding x64Parser::tokenCoding8291_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8285_19[] = { +Coding x64Parser::tokenCoding8291_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8285(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8291(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8285_16; - operand.values[17] = tokenCoding8285_17; - operand.values[18] = tokenCoding8285_18; - operand.values[19] = tokenCoding8285_19; + operand.values[16] = tokenCoding8291_16; + operand.values[17] = tokenCoding8291_17; + operand.values[18] = tokenCoding8291_18; + operand.values[19] = tokenCoding8291_19; } -x64Token x64Parser::tokenBranches8284[] = { - {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8285, }, +x64Token x64Parser::tokenBranches8290[] = { + {x64Token::ADDRESSCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8291, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8293_16[] = { +Coding x64Parser::tokenCoding8299_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_17[] = { +Coding x64Parser::tokenCoding8299_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_18[] = { +Coding x64Parser::tokenCoding8299_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8293_19[] = { +Coding x64Parser::tokenCoding8299_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8299(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34531,33 +34600,33 @@ void x64Parser::TokenFunc8293(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8293_16; - operand.values[17] = tokenCoding8293_17; - operand.values[18] = tokenCoding8293_18; - operand.values[19] = tokenCoding8293_19; + operand.values[16] = tokenCoding8299_16; + operand.values[17] = tokenCoding8299_17; + operand.values[18] = tokenCoding8299_18; + operand.values[19] = tokenCoding8299_19; } -Coding x64Parser::tokenCoding8297_16[] = { +Coding x64Parser::tokenCoding8303_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_17[] = { +Coding x64Parser::tokenCoding8303_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_23[] = { +Coding x64Parser::tokenCoding8303_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_18[] = { +Coding x64Parser::tokenCoding8303_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8297_19[] = { +Coding x64Parser::tokenCoding8303_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 192, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8303(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34568,44 +34637,44 @@ void x64Parser::TokenFunc8297(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8297_16; - operand.values[17] = tokenCoding8297_17; - operand.values[23] = tokenCoding8297_23; - operand.values[18] = tokenCoding8297_18; - operand.values[19] = tokenCoding8297_19; + operand.values[16] = tokenCoding8303_16; + operand.values[17] = tokenCoding8303_17; + operand.values[23] = tokenCoding8303_23; + operand.values[18] = tokenCoding8303_18; + operand.values[19] = tokenCoding8303_19; } -x64Token x64Parser::tokenBranches8292[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8293, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8297, }, +x64Token x64Parser::tokenBranches8298[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8299, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8303, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8291[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8292 }, +x64Token x64Parser::tokenBranches8297[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8298 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8290[] = { - {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8291 }, +x64Token x64Parser::tokenBranches8296[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8297 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8301_16[] = { +Coding x64Parser::tokenCoding8307_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_17[] = { +Coding x64Parser::tokenCoding8307_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_18[] = { +Coding x64Parser::tokenCoding8307_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8301_19[] = { +Coding x64Parser::tokenCoding8307_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8307(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34616,42 +34685,42 @@ void x64Parser::TokenFunc8301(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8301_16; - operand.values[17] = tokenCoding8301_17; - operand.values[18] = tokenCoding8301_18; - operand.values[19] = tokenCoding8301_19; + operand.values[16] = tokenCoding8307_16; + operand.values[17] = tokenCoding8307_17; + operand.values[18] = tokenCoding8307_18; + operand.values[19] = tokenCoding8307_19; } -x64Token x64Parser::tokenBranches8300[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8301, }, +x64Token x64Parser::tokenBranches8306[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8307, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8299[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8300 }, +x64Token x64Parser::tokenBranches8305[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8306 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8298[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8299 }, +x64Token x64Parser::tokenBranches8304[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8305 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8305_16[] = { +Coding x64Parser::tokenCoding8311_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_17[] = { +Coding x64Parser::tokenCoding8311_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_18[] = { +Coding x64Parser::tokenCoding8311_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8305_19[] = { +Coding x64Parser::tokenCoding8311_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8311(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34662,42 +34731,42 @@ void x64Parser::TokenFunc8305(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8305_16; - operand.values[17] = tokenCoding8305_17; - operand.values[18] = tokenCoding8305_18; - operand.values[19] = tokenCoding8305_19; + operand.values[16] = tokenCoding8311_16; + operand.values[17] = tokenCoding8311_17; + operand.values[18] = tokenCoding8311_18; + operand.values[19] = tokenCoding8311_19; } -x64Token x64Parser::tokenBranches8304[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8305, }, +x64Token x64Parser::tokenBranches8310[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8311, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8303[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8304 }, +x64Token x64Parser::tokenBranches8309[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8310 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8302[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8303 }, +x64Token x64Parser::tokenBranches8308[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8309 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8309_16[] = { +Coding x64Parser::tokenCoding8315_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_17[] = { +Coding x64Parser::tokenCoding8315_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_18[] = { +Coding x64Parser::tokenCoding8315_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8309_19[] = { +Coding x64Parser::tokenCoding8315_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 193, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8315(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -34708,33 +34777,33 @@ void x64Parser::TokenFunc8309(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8309_16; - operand.values[17] = tokenCoding8309_17; - operand.values[18] = tokenCoding8309_18; - operand.values[19] = tokenCoding8309_19; + operand.values[16] = tokenCoding8315_16; + operand.values[17] = tokenCoding8315_17; + operand.values[18] = tokenCoding8315_18; + operand.values[19] = tokenCoding8315_19; } -x64Token x64Parser::tokenBranches8308[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8309, }, +x64Token x64Parser::tokenBranches8314[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8315, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8307[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8308 }, +x64Token x64Parser::tokenBranches8313[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8306[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8307 }, +x64Token x64Parser::tokenBranches8312[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8313 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8289[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8290 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8298 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8302 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8306 }, +x64Token x64Parser::tokenBranches8295[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8296 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8304 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8308 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8312 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) { - operand.operandCoding = 722; + operand.operandCoding = 723; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34745,17 +34814,17 @@ void x64Parser::TokenFunc8313(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8312[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8313, }, +x64Token x64Parser::tokenBranches8318[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8319, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8311[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8312 }, +x64Token x64Parser::tokenBranches8317[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) { - operand.operandCoding = 723; + operand.operandCoding = 724; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34766,17 +34835,17 @@ void x64Parser::TokenFunc8316(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8315[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8316, }, +x64Token x64Parser::tokenBranches8321[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8322, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8314[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8315 }, +x64Token x64Parser::tokenBranches8320[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) { - operand.operandCoding = 724; + operand.operandCoding = 725; operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); operand.values[20]->type = Coding::reg; @@ -34787,229 +34856,229 @@ void x64Parser::TokenFunc8319(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8318[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8319, }, +x64Token x64Parser::tokenBranches8324[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8325, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8317[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8318 }, +x64Token x64Parser::tokenBranches8323[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8340_16[] = { +Coding x64Parser::tokenCoding8346_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_17[] = { +Coding x64Parser::tokenCoding8346_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_18[] = { +Coding x64Parser::tokenCoding8346_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8340_19[] = { +Coding x64Parser::tokenCoding8346_19[] = { { CODING_NAME("rm") Coding::stateFunc, 4 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8340(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8346(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8340_16; - operand.values[17] = tokenCoding8340_17; - operand.values[18] = tokenCoding8340_18; - operand.values[19] = tokenCoding8340_19; + operand.values[16] = tokenCoding8346_16; + operand.values[17] = tokenCoding8346_17; + operand.values[18] = tokenCoding8346_18; + operand.values[19] = tokenCoding8346_19; } -x64Token x64Parser::tokenBranches8339[] = { - {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8340, }, +x64Token x64Parser::tokenBranches8345[] = { + {x64Token::ADDRESSCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8346, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8322(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) { - operand.operandCoding = 722; + operand.operandCoding = 723; } -x64Token x64Parser::tokenBranches8321[] = { - {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8322, }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8339 }, +x64Token x64Parser::tokenBranches8327[] = { + {x64Token::REGISTER, 2, 1, 0, NULL,&x64Parser::TokenFunc8328, }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8345 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8320[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8321 }, +x64Token x64Parser::tokenBranches8326[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8344_16[] = { +Coding x64Parser::tokenCoding8350_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_17[] = { +Coding x64Parser::tokenCoding8350_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_18[] = { +Coding x64Parser::tokenCoding8350_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8344_19[] = { +Coding x64Parser::tokenCoding8350_19[] = { { CODING_NAME("rm") Coding::stateFunc, 5 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8344(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8350(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8344_16; - operand.values[17] = tokenCoding8344_17; - operand.values[18] = tokenCoding8344_18; - operand.values[19] = tokenCoding8344_19; + operand.values[16] = tokenCoding8350_16; + operand.values[17] = tokenCoding8350_17; + operand.values[18] = tokenCoding8350_18; + operand.values[19] = tokenCoding8350_19; } -x64Token x64Parser::tokenBranches8343[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8344, }, +x64Token x64Parser::tokenBranches8349[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8350, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8325(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8331(x64Operand &operand, int tokenPos) { - operand.operandCoding = 723; + operand.operandCoding = 724; } -x64Token x64Parser::tokenBranches8324[] = { - {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8325, }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8343 }, +x64Token x64Parser::tokenBranches8330[] = { + {x64Token::REGISTER, 3, 1, 0, NULL,&x64Parser::TokenFunc8331, }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8323[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8324 }, +x64Token x64Parser::tokenBranches8329[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8348_16[] = { +Coding x64Parser::tokenCoding8354_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_17[] = { +Coding x64Parser::tokenCoding8354_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_18[] = { +Coding x64Parser::tokenCoding8354_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8348_19[] = { +Coding x64Parser::tokenCoding8354_19[] = { { CODING_NAME("rm") Coding::stateFunc, 6 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8348(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8354(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8348_16; - operand.values[17] = tokenCoding8348_17; - operand.values[18] = tokenCoding8348_18; - operand.values[19] = tokenCoding8348_19; + operand.values[16] = tokenCoding8354_16; + operand.values[17] = tokenCoding8354_17; + operand.values[18] = tokenCoding8354_18; + operand.values[19] = tokenCoding8354_19; } -x64Token x64Parser::tokenBranches8347[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8348, }, +x64Token x64Parser::tokenBranches8353[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8354, }, {x64Token::EOT } }; -void x64Parser::TokenFunc8328(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8334(x64Operand &operand, int tokenPos) { - operand.operandCoding = 724; + operand.operandCoding = 725; } -x64Token x64Parser::tokenBranches8327[] = { - {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8328, }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8347 }, +x64Token x64Parser::tokenBranches8333[] = { + {x64Token::REGISTER, 4, 1, 0, NULL,&x64Parser::TokenFunc8334, }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8353 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8326[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8327 }, +x64Token x64Parser::tokenBranches8332[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8333 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8332_16[] = { +Coding x64Parser::tokenCoding8338_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_17[] = { +Coding x64Parser::tokenCoding8338_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_18[] = { +Coding x64Parser::tokenCoding8338_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8332_19[] = { +Coding x64Parser::tokenCoding8338_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8338(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8332_16; - operand.values[17] = tokenCoding8332_17; - operand.values[18] = tokenCoding8332_18; - operand.values[19] = tokenCoding8332_19; + operand.values[16] = tokenCoding8338_16; + operand.values[17] = tokenCoding8338_17; + operand.values[18] = tokenCoding8338_18; + operand.values[19] = tokenCoding8338_19; } -x64Token x64Parser::tokenBranches8331[] = { - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8332, }, +x64Token x64Parser::tokenBranches8337[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8338, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8330[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8331 }, +x64Token x64Parser::tokenBranches8336[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8337 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8329[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8330 }, +x64Token x64Parser::tokenBranches8335[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8336 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8336_16[] = { +Coding x64Parser::tokenCoding8342_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_17[] = { +Coding x64Parser::tokenCoding8342_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_23[] = { +Coding x64Parser::tokenCoding8342_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_18[] = { +Coding x64Parser::tokenCoding8342_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8336_19[] = { +Coding x64Parser::tokenCoding8342_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8336(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8342(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8336_16; - operand.values[17] = tokenCoding8336_17; - operand.values[23] = tokenCoding8336_23; - operand.values[18] = tokenCoding8336_18; - operand.values[19] = tokenCoding8336_19; + operand.values[16] = tokenCoding8342_16; + operand.values[17] = tokenCoding8342_17; + operand.values[23] = tokenCoding8342_23; + operand.values[18] = tokenCoding8342_18; + operand.values[19] = tokenCoding8342_19; } -x64Token x64Parser::tokenBranches8335[] = { - {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8336, }, +x64Token x64Parser::tokenBranches8341[] = { + {x64Token::ADDRESSCLASS, 3, 1, 0, NULL,&x64Parser::TokenFunc8342, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8334[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8335 }, +x64Token x64Parser::tokenBranches8340[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8341 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8333[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8334 }, +x64Token x64Parser::tokenBranches8339[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8340 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8352_16[] = { +Coding x64Parser::tokenCoding8358_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_17[] = { +Coding x64Parser::tokenCoding8358_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_18[] = { +Coding x64Parser::tokenCoding8358_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8352_19[] = { +Coding x64Parser::tokenCoding8358_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8358(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35020,32 +35089,32 @@ void x64Parser::TokenFunc8352(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8352_16; - operand.values[17] = tokenCoding8352_17; - operand.values[18] = tokenCoding8352_18; - operand.values[19] = tokenCoding8352_19; + operand.values[16] = tokenCoding8358_16; + operand.values[17] = tokenCoding8358_17; + operand.values[18] = tokenCoding8358_18; + operand.values[19] = tokenCoding8358_19; } -Coding x64Parser::tokenCoding8356_16[] = { +Coding x64Parser::tokenCoding8362_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_17[] = { +Coding x64Parser::tokenCoding8362_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_23[] = { +Coding x64Parser::tokenCoding8362_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_18[] = { +Coding x64Parser::tokenCoding8362_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8356_19[] = { +Coding x64Parser::tokenCoding8362_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 134, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8362(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35056,43 +35125,43 @@ void x64Parser::TokenFunc8356(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8356_16; - operand.values[17] = tokenCoding8356_17; - operand.values[23] = tokenCoding8356_23; - operand.values[18] = tokenCoding8356_18; - operand.values[19] = tokenCoding8356_19; + operand.values[16] = tokenCoding8362_16; + operand.values[17] = tokenCoding8362_17; + operand.values[23] = tokenCoding8362_23; + operand.values[18] = tokenCoding8362_18; + operand.values[19] = tokenCoding8362_19; } -x64Token x64Parser::tokenBranches8351[] = { - {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8352, }, - {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8356, }, +x64Token x64Parser::tokenBranches8357[] = { + {x64Token::REGISTERCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8358, }, + {x64Token::REGISTERCLASS, 14, 1, 0, NULL,&x64Parser::TokenFunc8362, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8350[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8351 }, +x64Token x64Parser::tokenBranches8356[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8357 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8349[] = { - {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8350 }, +x64Token x64Parser::tokenBranches8355[] = { + {x64Token::ADDRESSCLASS, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8356 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8360_16[] = { +Coding x64Parser::tokenCoding8366_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_17[] = { +Coding x64Parser::tokenCoding8366_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_18[] = { +Coding x64Parser::tokenCoding8366_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8360_19[] = { +Coding x64Parser::tokenCoding8366_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 4 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8366(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35103,41 +35172,41 @@ void x64Parser::TokenFunc8360(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8360_16; - operand.values[17] = tokenCoding8360_17; - operand.values[18] = tokenCoding8360_18; - operand.values[19] = tokenCoding8360_19; + operand.values[16] = tokenCoding8366_16; + operand.values[17] = tokenCoding8366_17; + operand.values[18] = tokenCoding8366_18; + operand.values[19] = tokenCoding8366_19; } -x64Token x64Parser::tokenBranches8359[] = { - {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8360, }, +x64Token x64Parser::tokenBranches8365[] = { + {x64Token::REGISTERCLASS, 4, 1, 0, NULL,&x64Parser::TokenFunc8366, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8358[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8359 }, +x64Token x64Parser::tokenBranches8364[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8365 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8357[] = { - {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8358 }, +x64Token x64Parser::tokenBranches8363[] = { + {x64Token::ADDRESSCLASS, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8364 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8364_16[] = { +Coding x64Parser::tokenCoding8370_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_17[] = { +Coding x64Parser::tokenCoding8370_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_18[] = { +Coding x64Parser::tokenCoding8370_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8364_19[] = { +Coding x64Parser::tokenCoding8370_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 5 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8370(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35148,41 +35217,41 @@ void x64Parser::TokenFunc8364(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8364_16; - operand.values[17] = tokenCoding8364_17; - operand.values[18] = tokenCoding8364_18; - operand.values[19] = tokenCoding8364_19; + operand.values[16] = tokenCoding8370_16; + operand.values[17] = tokenCoding8370_17; + operand.values[18] = tokenCoding8370_18; + operand.values[19] = tokenCoding8370_19; } -x64Token x64Parser::tokenBranches8363[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8364, }, +x64Token x64Parser::tokenBranches8369[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8370, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8362[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8363 }, +x64Token x64Parser::tokenBranches8368[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8369 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8361[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8362 }, +x64Token x64Parser::tokenBranches8367[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8368 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8368_16[] = { +Coding x64Parser::tokenCoding8374_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_17[] = { +Coding x64Parser::tokenCoding8374_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_18[] = { +Coding x64Parser::tokenCoding8374_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8368_19[] = { +Coding x64Parser::tokenCoding8374_19[] = { { CODING_NAME("modreg") Coding::stateFunc, 6 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 135, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8374(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35193,24 +35262,24 @@ void x64Parser::TokenFunc8368(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8368_16; - operand.values[17] = tokenCoding8368_17; - operand.values[18] = tokenCoding8368_18; - operand.values[19] = tokenCoding8368_19; + operand.values[16] = tokenCoding8374_16; + operand.values[17] = tokenCoding8374_17; + operand.values[18] = tokenCoding8374_18; + operand.values[19] = tokenCoding8374_19; } -x64Token x64Parser::tokenBranches8367[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8368, }, +x64Token x64Parser::tokenBranches8373[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8374, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8366[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8367 }, +x64Token x64Parser::tokenBranches8372[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8365[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8366 }, +x64Token x64Parser::tokenBranches8371[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35222,7 +35291,7 @@ void x64Parser::TokenFunc8320(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35234,7 +35303,7 @@ void x64Parser::TokenFunc8323(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8332(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35246,7 +35315,7 @@ void x64Parser::TokenFunc8326(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8335(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35258,7 +35327,7 @@ void x64Parser::TokenFunc8329(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8339(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35270,53 +35339,19 @@ void x64Parser::TokenFunc8333(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8310[] = { - {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8311 }, - {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8314 }, - {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, - {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8320, x64Parser::tokenBranches8320 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8323, x64Parser::tokenBranches8323 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, - {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, - {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8333, x64Parser::tokenBranches8333 }, - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8349 }, - {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8357 }, - {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8361 }, - {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8365 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8375(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 725; -} -x64Token x64Parser::tokenBranches8374[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8375, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 727; -} -x64Token x64Parser::tokenBranches8386[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 729; -} -x64Token x64Parser::tokenBranches8398[] = { - {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8373[] = { - {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8374 }, - {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, - {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8372[] = { - {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8373 }, +x64Token x64Parser::tokenBranches8316[] = { + {x64Token::REGISTER, 2, 0, 0, NULL, NULL, x64Parser::tokenBranches8317 }, + {x64Token::REGISTER, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8320 }, + {x64Token::REGISTER, 4, 0, 0, NULL, NULL, x64Parser::tokenBranches8323 }, + {x64Token::REGISTERCLASS, 4, 0, 0, NULL,&x64Parser::TokenFunc8326, x64Parser::tokenBranches8326 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8329, x64Parser::tokenBranches8329 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8332, x64Parser::tokenBranches8332 }, + {x64Token::REGISTERCLASS, 1, 0, 0, NULL,&x64Parser::TokenFunc8335, x64Parser::tokenBranches8335 }, + {x64Token::REGISTERCLASS, 14, 0, 0, NULL,&x64Parser::TokenFunc8339, x64Parser::tokenBranches8339 }, + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8355 }, + {x64Token::TOKEN, 8, 0, 1, NULL, NULL, x64Parser::tokenBranches8363 }, + {x64Token::TOKEN, 9, 0, 1, NULL, NULL, x64Parser::tokenBranches8367 }, + {x64Token::TOKEN, 10, 0, 1, NULL, NULL, x64Parser::tokenBranches8371 }, {x64Token::EOT } }; void x64Parser::TokenFunc8381(x64Operand &operand, int tokenPos) @@ -35353,7 +35388,41 @@ x64Token x64Parser::tokenBranches8378[] = { {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8379 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8387(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 727; +} +x64Token x64Parser::tokenBranches8386[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8387, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8399(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 729; +} +x64Token x64Parser::tokenBranches8398[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8399, }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8411(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 731; +} +x64Token x64Parser::tokenBranches8410[] = { + {x64Token::TOKEN, 2, 1, 0, NULL,&x64Parser::TokenFunc8411, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8385[] = { + {x64Token::REGISTER, 29, 0, 0, NULL, NULL, x64Parser::tokenBranches8386 }, + {x64Token::REGISTER, 30, 0, 0, NULL, NULL, x64Parser::tokenBranches8398 }, + {x64Token::REGISTER, 31, 0, 0, NULL, NULL, x64Parser::tokenBranches8410 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8384[] = { + {x64Token::TOKEN, 3, 0, 0, NULL, NULL, x64Parser::tokenBranches8385 }, + {x64Token::EOT } +}; +void x64Parser::TokenFunc8384(x64Operand &operand, int tokenPos) { operand.values[2] = new Coding[2]; CleanupValues.push_back(operand.values[2]); @@ -35365,174 +35434,174 @@ void x64Parser::TokenFunc8378(x64Operand &operand, int tokenPos) operand.values[2]->binary = 0; operand.values[2][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8371[] = { - {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8372 }, - {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8378, x64Parser::tokenBranches8378 }, +x64Token x64Parser::tokenBranches8377[] = { + {x64Token::REGISTER, 96, 0, 0, NULL, NULL, x64Parser::tokenBranches8378 }, + {x64Token::REGISTERCLASS, 19, 0, 0, NULL,&x64Parser::TokenFunc8384, x64Parser::tokenBranches8384 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8370[] = { - {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8371 }, +x64Token x64Parser::tokenBranches8376[] = { + {x64Token::TOKEN, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8377 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8406(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) { - operand.operandCoding = 731; + operand.operandCoding = 732; } -x64Token x64Parser::tokenBranches8369[] = { - {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8370 }, - {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8406, }, +x64Token x64Parser::tokenBranches8375[] = { + {x64Token::TOKEN, 11, 0, 1, NULL, NULL, x64Parser::tokenBranches8376 }, + {x64Token::EMPTY, 0, 1, 0, NULL,&x64Parser::TokenFunc8412, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8410_16[] = { +Coding x64Parser::tokenCoding8416_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_17[] = { +Coding x64Parser::tokenCoding8416_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_18[] = { +Coding x64Parser::tokenCoding8416_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8410_19[] = { +Coding x64Parser::tokenCoding8416_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8410(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8410_16; - operand.values[17] = tokenCoding8410_17; - operand.values[18] = tokenCoding8410_18; - operand.values[19] = tokenCoding8410_19; + operand.values[16] = tokenCoding8416_16; + operand.values[17] = tokenCoding8416_17; + operand.values[18] = tokenCoding8416_18; + operand.values[19] = tokenCoding8416_19; } -x64Token x64Parser::tokenBranches8409[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8410, }, +x64Token x64Parser::tokenBranches8415[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8412_16[] = { +Coding x64Parser::tokenCoding8418_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_17[] = { +Coding x64Parser::tokenCoding8418_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_18[] = { +Coding x64Parser::tokenCoding8418_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8412_19[] = { +Coding x64Parser::tokenCoding8418_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8412(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8418(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8412_16; - operand.values[17] = tokenCoding8412_17; - operand.values[18] = tokenCoding8412_18; - operand.values[19] = tokenCoding8412_19; + operand.values[16] = tokenCoding8418_16; + operand.values[17] = tokenCoding8418_17; + operand.values[18] = tokenCoding8418_18; + operand.values[19] = tokenCoding8418_19; } -x64Token x64Parser::tokenBranches8411[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8412, }, +x64Token x64Parser::tokenBranches8417[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8418, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8414_16[] = { +Coding x64Parser::tokenCoding8420_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_17[] = { +Coding x64Parser::tokenCoding8420_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_18[] = { +Coding x64Parser::tokenCoding8420_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8414_19[] = { +Coding x64Parser::tokenCoding8420_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8414(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8420(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8414_16; - operand.values[17] = tokenCoding8414_17; - operand.values[18] = tokenCoding8414_18; - operand.values[19] = tokenCoding8414_19; + operand.values[16] = tokenCoding8420_16; + operand.values[17] = tokenCoding8420_17; + operand.values[18] = tokenCoding8420_18; + operand.values[19] = tokenCoding8420_19; } -x64Token x64Parser::tokenBranches8413[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8414, }, +x64Token x64Parser::tokenBranches8419[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8420, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8416_16[] = { +Coding x64Parser::tokenCoding8422_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_17[] = { +Coding x64Parser::tokenCoding8422_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_18[] = { +Coding x64Parser::tokenCoding8422_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8416_19[] = { +Coding x64Parser::tokenCoding8422_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8416(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8422(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8416_16; - operand.values[17] = tokenCoding8416_17; - operand.values[18] = tokenCoding8416_18; - operand.values[19] = tokenCoding8416_19; + operand.values[16] = tokenCoding8422_16; + operand.values[17] = tokenCoding8422_17; + operand.values[18] = tokenCoding8422_18; + operand.values[19] = tokenCoding8422_19; } -x64Token x64Parser::tokenBranches8415[] = { - {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8416, }, +x64Token x64Parser::tokenBranches8421[] = { + {x64Token::ADDRESSCLASS, 1, 1, 0, NULL,&x64Parser::TokenFunc8422, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8469_16[] = { +Coding x64Parser::tokenCoding8475_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_17[] = { +Coding x64Parser::tokenCoding8475_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_23[] = { +Coding x64Parser::tokenCoding8475_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_18[] = { +Coding x64Parser::tokenCoding8475_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8469_19[] = { +Coding x64Parser::tokenCoding8475_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8469(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8475(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8469_16; - operand.values[17] = tokenCoding8469_17; - operand.values[23] = tokenCoding8469_23; - operand.values[18] = tokenCoding8469_18; - operand.values[19] = tokenCoding8469_19; + operand.values[16] = tokenCoding8475_16; + operand.values[17] = tokenCoding8475_17; + operand.values[23] = tokenCoding8475_23; + operand.values[18] = tokenCoding8475_18; + operand.values[19] = tokenCoding8475_19; } -x64Token x64Parser::tokenBranches8468[] = { - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8469, }, +x64Token x64Parser::tokenBranches8474[] = { + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8475, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8467[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8468 }, +x64Token x64Parser::tokenBranches8473[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8474 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35544,47 +35613,47 @@ void x64Parser::TokenFunc8467(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8466[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8467, x64Parser::tokenBranches8467 }, +x64Token x64Parser::tokenBranches8472[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8473, x64Parser::tokenBranches8473 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8473_16[] = { +Coding x64Parser::tokenCoding8479_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_17[] = { +Coding x64Parser::tokenCoding8479_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_23[] = { +Coding x64Parser::tokenCoding8479_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_18[] = { +Coding x64Parser::tokenCoding8479_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8473_19[] = { +Coding x64Parser::tokenCoding8479_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8473(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8479(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8473_16; - operand.values[17] = tokenCoding8473_17; - operand.values[23] = tokenCoding8473_23; - operand.values[18] = tokenCoding8473_18; - operand.values[19] = tokenCoding8473_19; + operand.values[16] = tokenCoding8479_16; + operand.values[17] = tokenCoding8479_17; + operand.values[23] = tokenCoding8479_23; + operand.values[18] = tokenCoding8479_18; + operand.values[19] = tokenCoding8479_19; } -x64Token x64Parser::tokenBranches8472[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8473, }, +x64Token x64Parser::tokenBranches8478[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8479, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8471[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8472 }, +x64Token x64Parser::tokenBranches8477[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8478 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8477(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35596,104 +35665,104 @@ void x64Parser::TokenFunc8471(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8470[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8471, x64Parser::tokenBranches8471 }, +x64Token x64Parser::tokenBranches8476[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8477, x64Parser::tokenBranches8477 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8490_16[] = { +Coding x64Parser::tokenCoding8496_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_17[] = { +Coding x64Parser::tokenCoding8496_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_23[] = { +Coding x64Parser::tokenCoding8496_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_18[] = { +Coding x64Parser::tokenCoding8496_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8490_19[] = { +Coding x64Parser::tokenCoding8496_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8490(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8490_16; - operand.values[17] = tokenCoding8490_17; - operand.values[23] = tokenCoding8490_23; - operand.values[18] = tokenCoding8490_18; - operand.values[19] = tokenCoding8490_19; + operand.values[16] = tokenCoding8496_16; + operand.values[17] = tokenCoding8496_17; + operand.values[23] = tokenCoding8496_23; + operand.values[18] = tokenCoding8496_18; + operand.values[19] = tokenCoding8496_19; } -x64Token x64Parser::tokenBranches8489[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8490, }, +x64Token x64Parser::tokenBranches8495[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8496, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8488[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8489 }, +x64Token x64Parser::tokenBranches8494[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8493_16[] = { +Coding x64Parser::tokenCoding8499_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_17[] = { +Coding x64Parser::tokenCoding8499_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_23[] = { +Coding x64Parser::tokenCoding8499_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_18[] = { +Coding x64Parser::tokenCoding8499_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8493_19[] = { +Coding x64Parser::tokenCoding8499_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8493(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8493_16; - operand.values[17] = tokenCoding8493_17; - operand.values[23] = tokenCoding8493_23; - operand.values[18] = tokenCoding8493_18; - operand.values[19] = tokenCoding8493_19; + operand.values[16] = tokenCoding8499_16; + operand.values[17] = tokenCoding8499_17; + operand.values[23] = tokenCoding8499_23; + operand.values[18] = tokenCoding8499_18; + operand.values[19] = tokenCoding8499_19; } -x64Token x64Parser::tokenBranches8492[] = { - {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8493, }, +x64Token x64Parser::tokenBranches8498[] = { + {x64Token::ADDRESSCLASS, 5, 1, 0, NULL,&x64Parser::TokenFunc8499, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8491[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8492 }, +x64Token x64Parser::tokenBranches8497[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8498 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8496_16[] = { +Coding x64Parser::tokenCoding8502_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_17[] = { +Coding x64Parser::tokenCoding8502_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_23[] = { +Coding x64Parser::tokenCoding8502_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_18[] = { +Coding x64Parser::tokenCoding8502_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8496_19[] = { +Coding x64Parser::tokenCoding8502_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8502(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35704,34 +35773,34 @@ void x64Parser::TokenFunc8496(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8496_16; - operand.values[17] = tokenCoding8496_17; - operand.values[23] = tokenCoding8496_23; - operand.values[18] = tokenCoding8496_18; - operand.values[19] = tokenCoding8496_19; + operand.values[16] = tokenCoding8502_16; + operand.values[17] = tokenCoding8502_17; + operand.values[23] = tokenCoding8502_23; + operand.values[18] = tokenCoding8502_18; + operand.values[19] = tokenCoding8502_19; } -Coding x64Parser::tokenCoding8499_16[] = { +Coding x64Parser::tokenCoding8505_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_17[] = { +Coding x64Parser::tokenCoding8505_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_23[] = { +Coding x64Parser::tokenCoding8505_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_18[] = { +Coding x64Parser::tokenCoding8505_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8499_19[] = { +Coding x64Parser::tokenCoding8505_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8505(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35742,22 +35811,22 @@ void x64Parser::TokenFunc8499(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8499_16; - operand.values[17] = tokenCoding8499_17; - operand.values[23] = tokenCoding8499_23; - operand.values[18] = tokenCoding8499_18; - operand.values[19] = tokenCoding8499_19; + operand.values[16] = tokenCoding8505_16; + operand.values[17] = tokenCoding8505_17; + operand.values[23] = tokenCoding8505_23; + operand.values[18] = tokenCoding8505_18; + operand.values[19] = tokenCoding8505_19; } -x64Token x64Parser::tokenBranches8495[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8496, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8499, }, +x64Token x64Parser::tokenBranches8501[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8502, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8505, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8494[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8495 }, +x64Token x64Parser::tokenBranches8500[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8494(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35769,7 +35838,7 @@ void x64Parser::TokenFunc8488(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8497(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35781,33 +35850,33 @@ void x64Parser::TokenFunc8491(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8487[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8488, x64Parser::tokenBranches8488 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8491, x64Parser::tokenBranches8491 }, - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8494 }, +x64Token x64Parser::tokenBranches8493[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8494, x64Parser::tokenBranches8494 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8497, x64Parser::tokenBranches8497 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8500 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8503_16[] = { +Coding x64Parser::tokenCoding8509_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_17[] = { +Coding x64Parser::tokenCoding8509_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_23[] = { +Coding x64Parser::tokenCoding8509_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_18[] = { +Coding x64Parser::tokenCoding8509_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8503_19[] = { +Coding x64Parser::tokenCoding8509_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -35818,160 +35887,123 @@ void x64Parser::TokenFunc8503(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8503_16; - operand.values[17] = tokenCoding8503_17; - operand.values[23] = tokenCoding8503_23; - operand.values[18] = tokenCoding8503_18; - operand.values[19] = tokenCoding8503_19; + operand.values[16] = tokenCoding8509_16; + operand.values[17] = tokenCoding8509_17; + operand.values[23] = tokenCoding8509_23; + operand.values[18] = tokenCoding8509_18; + operand.values[19] = tokenCoding8509_19; } -x64Token x64Parser::tokenBranches8502[] = { - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8503, }, +x64Token x64Parser::tokenBranches8508[] = { + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8509, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8501[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8502 }, +x64Token x64Parser::tokenBranches8507[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8506_16[] = { +Coding x64Parser::tokenCoding8512_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_17[] = { +Coding x64Parser::tokenCoding8512_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_23[] = { +Coding x64Parser::tokenCoding8512_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_18[] = { +Coding x64Parser::tokenCoding8512_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8506_19[] = { +Coding x64Parser::tokenCoding8512_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8506(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8506_16; - operand.values[17] = tokenCoding8506_17; - operand.values[23] = tokenCoding8506_23; - operand.values[18] = tokenCoding8506_18; - operand.values[19] = tokenCoding8506_19; + operand.values[16] = tokenCoding8512_16; + operand.values[17] = tokenCoding8512_17; + operand.values[23] = tokenCoding8512_23; + operand.values[18] = tokenCoding8512_18; + operand.values[19] = tokenCoding8512_19; } -x64Token x64Parser::tokenBranches8505[] = { - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8506, }, +x64Token x64Parser::tokenBranches8511[] = { + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8504[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8505 }, +x64Token x64Parser::tokenBranches8510[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8511 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8509_16[] = { +Coding x64Parser::tokenCoding8515_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_17[] = { +Coding x64Parser::tokenCoding8515_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_23[] = { +Coding x64Parser::tokenCoding8515_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_18[] = { +Coding x64Parser::tokenCoding8515_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8509_19[] = { +Coding x64Parser::tokenCoding8515_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8509(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8509_16; - operand.values[17] = tokenCoding8509_17; - operand.values[23] = tokenCoding8509_23; - operand.values[18] = tokenCoding8509_18; - operand.values[19] = tokenCoding8509_19; + operand.values[16] = tokenCoding8515_16; + operand.values[17] = tokenCoding8515_17; + operand.values[23] = tokenCoding8515_23; + operand.values[18] = tokenCoding8515_18; + operand.values[19] = tokenCoding8515_19; } -Coding x64Parser::tokenCoding8512_16[] = { +Coding x64Parser::tokenCoding8518_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_17[] = { +Coding x64Parser::tokenCoding8518_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_23[] = { +Coding x64Parser::tokenCoding8518_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_18[] = { +Coding x64Parser::tokenCoding8518_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8512_19[] = { +Coding x64Parser::tokenCoding8518_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8512(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8512_16; - operand.values[17] = tokenCoding8512_17; - operand.values[23] = tokenCoding8512_23; - operand.values[18] = tokenCoding8512_18; - operand.values[19] = tokenCoding8512_19; + operand.values[16] = tokenCoding8518_16; + operand.values[17] = tokenCoding8518_17; + operand.values[23] = tokenCoding8518_23; + operand.values[18] = tokenCoding8518_18; + operand.values[19] = tokenCoding8518_19; } -x64Token x64Parser::tokenBranches8508[] = { - {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8509, }, - {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8512, }, +x64Token x64Parser::tokenBranches8514[] = { + {x64Token::ADDRESSCLASS, 21, 1, 0, NULL,&x64Parser::TokenFunc8515, }, + {x64Token::ADDRESSCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8518, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8507[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8508 }, +x64Token x64Parser::tokenBranches8513[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8515_16[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_17[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_18[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8515_19[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc8515(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8515_16; - operand.values[17] = tokenCoding8515_17; - operand.values[23] = tokenCoding8515_23; - operand.values[18] = tokenCoding8515_18; - operand.values[19] = tokenCoding8515_19; -} Coding x64Parser::tokenCoding8521_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, @@ -35981,7 +36013,6 @@ Coding x64Parser::tokenCoding8521_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_23[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8521_18[] = { @@ -36010,36 +36041,28 @@ void x64Parser::TokenFunc8521(x64Operand &operand, int tokenPos) operand.values[18] = tokenCoding8521_18; operand.values[19] = tokenCoding8521_19; } -x64Token x64Parser::tokenBranches8514[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8515, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8521, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8513[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8514 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8518_16[] = { +Coding x64Parser::tokenCoding8527_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_17[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, +Coding x64Parser::tokenCoding8527_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_23[] = { +Coding x64Parser::tokenCoding8527_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_18[] = { +Coding x64Parser::tokenCoding8527_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8518_19[] = { +Coding x64Parser::tokenCoding8527_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 126, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8527(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36050,12 +36073,21 @@ void x64Parser::TokenFunc8518(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8518_16; - operand.values[17] = tokenCoding8518_17; - operand.values[23] = tokenCoding8518_23; - operand.values[18] = tokenCoding8518_18; - operand.values[19] = tokenCoding8518_19; + operand.values[16] = tokenCoding8527_16; + operand.values[17] = tokenCoding8527_17; + operand.values[23] = tokenCoding8527_23; + operand.values[18] = tokenCoding8527_18; + operand.values[19] = tokenCoding8527_19; } +x64Token x64Parser::tokenBranches8520[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8521, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8527, }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8519[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8520 }, + {x64Token::EOT } +}; Coding x64Parser::tokenCoding8524_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, @@ -36065,7 +36097,6 @@ Coding x64Parser::tokenCoding8524_17[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_23[] = { - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8524_18[] = { @@ -36074,7 +36105,7 @@ Coding x64Parser::tokenCoding8524_18[] = { }; Coding x64Parser::tokenCoding8524_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 127, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) @@ -36094,16 +36125,54 @@ void x64Parser::TokenFunc8524(x64Operand &operand, int tokenPos) operand.values[18] = tokenCoding8524_18; operand.values[19] = tokenCoding8524_19; } -x64Token x64Parser::tokenBranches8517[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8518, }, - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8524, }, +Coding x64Parser::tokenCoding8530_16[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_17[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_23[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_18[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8530_19[] = { + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; + operand.values[16] = tokenCoding8530_16; + operand.values[17] = tokenCoding8530_17; + operand.values[23] = tokenCoding8530_23; + operand.values[18] = tokenCoding8530_18; + operand.values[19] = tokenCoding8530_19; +} +x64Token x64Parser::tokenBranches8523[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8524, }, + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8530, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8516[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8517 }, +x64Token x64Parser::tokenBranches8522[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8523 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8510(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36115,7 +36184,7 @@ void x64Parser::TokenFunc8504(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8513(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36127,51 +36196,51 @@ void x64Parser::TokenFunc8507(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8500[] = { - {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8501 }, - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8504, x64Parser::tokenBranches8504 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8507, x64Parser::tokenBranches8507 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8513 }, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8516 }, +x64Token x64Parser::tokenBranches8506[] = { + {x64Token::ADDRESSCLASS, 24, 0, 0, NULL, NULL, x64Parser::tokenBranches8507 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8510, x64Parser::tokenBranches8510 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8513, x64Parser::tokenBranches8513 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8519 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8522 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8532_16[] = { +Coding x64Parser::tokenCoding8538_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_17[] = { +Coding x64Parser::tokenCoding8538_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_23[] = { +Coding x64Parser::tokenCoding8538_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_18[] = { +Coding x64Parser::tokenCoding8538_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8532_19[] = { +Coding x64Parser::tokenCoding8538_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8532(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8532_16; - operand.values[17] = tokenCoding8532_17; - operand.values[23] = tokenCoding8532_23; - operand.values[18] = tokenCoding8532_18; - operand.values[19] = tokenCoding8532_19; + operand.values[16] = tokenCoding8538_16; + operand.values[17] = tokenCoding8538_17; + operand.values[23] = tokenCoding8538_23; + operand.values[18] = tokenCoding8538_18; + operand.values[19] = tokenCoding8538_19; } -x64Token x64Parser::tokenBranches8531[] = { - {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8532, }, +x64Token x64Parser::tokenBranches8537[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8530[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8531 }, +x64Token x64Parser::tokenBranches8536[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36183,47 +36252,47 @@ void x64Parser::TokenFunc8530(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8529[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8530, x64Parser::tokenBranches8530 }, +x64Token x64Parser::tokenBranches8535[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8538_16[] = { +Coding x64Parser::tokenCoding8544_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_17[] = { +Coding x64Parser::tokenCoding8544_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_23[] = { +Coding x64Parser::tokenCoding8544_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_18[] = { +Coding x64Parser::tokenCoding8544_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8538_19[] = { +Coding x64Parser::tokenCoding8544_19[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8538(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8544(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8538_16; - operand.values[17] = tokenCoding8538_17; - operand.values[23] = tokenCoding8538_23; - operand.values[18] = tokenCoding8538_18; - operand.values[19] = tokenCoding8538_19; + operand.values[16] = tokenCoding8544_16; + operand.values[17] = tokenCoding8544_17; + operand.values[23] = tokenCoding8544_23; + operand.values[18] = tokenCoding8544_18; + operand.values[19] = tokenCoding8544_19; } -x64Token x64Parser::tokenBranches8537[] = { - {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8538, }, +x64Token x64Parser::tokenBranches8543[] = { + {x64Token::ADDRESSCLASS, 27, 1, 0, NULL,&x64Parser::TokenFunc8544, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8536[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8537 }, +x64Token x64Parser::tokenBranches8542[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8543 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8542(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36235,32 +36304,32 @@ void x64Parser::TokenFunc8536(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8535[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8536, x64Parser::tokenBranches8536 }, +x64Token x64Parser::tokenBranches8541[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8542, x64Parser::tokenBranches8542 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8546_16[] = { +Coding x64Parser::tokenCoding8552_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_17[] = { +Coding x64Parser::tokenCoding8552_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_23[] = { +Coding x64Parser::tokenCoding8552_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_18[] = { +Coding x64Parser::tokenCoding8552_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8546_19[] = { +Coding x64Parser::tokenCoding8552_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8552(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36271,37 +36340,37 @@ void x64Parser::TokenFunc8546(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8546_16; - operand.values[17] = tokenCoding8546_17; - operand.values[23] = tokenCoding8546_23; - operand.values[18] = tokenCoding8546_18; - operand.values[19] = tokenCoding8546_19; + operand.values[16] = tokenCoding8552_16; + operand.values[17] = tokenCoding8552_17; + operand.values[23] = tokenCoding8552_23; + operand.values[18] = tokenCoding8552_18; + operand.values[19] = tokenCoding8552_19; } -x64Token x64Parser::tokenBranches8545[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8546, }, +x64Token x64Parser::tokenBranches8551[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8552, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8544[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8545 }, +x64Token x64Parser::tokenBranches8550[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8551 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8543[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8544 }, +x64Token x64Parser::tokenBranches8549[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8550 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8550_16[] = { +Coding x64Parser::tokenCoding8556_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8550_17[] = { +Coding x64Parser::tokenCoding8556_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8550_18[] = { +Coding x64Parser::tokenCoding8556_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8556(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36312,23 +36381,23 @@ void x64Parser::TokenFunc8550(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8550_16; - operand.values[17] = tokenCoding8550_17; - operand.values[18] = tokenCoding8550_18; + operand.values[16] = tokenCoding8556_16; + operand.values[17] = tokenCoding8556_17; + operand.values[18] = tokenCoding8556_18; } -Coding x64Parser::tokenCoding8553_16[] = { +Coding x64Parser::tokenCoding8559_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8553_17[] = { +Coding x64Parser::tokenCoding8559_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8553_18[] = { +Coding x64Parser::tokenCoding8559_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8559(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36339,45 +36408,45 @@ void x64Parser::TokenFunc8553(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8553_16; - operand.values[17] = tokenCoding8553_17; - operand.values[18] = tokenCoding8553_18; + operand.values[16] = tokenCoding8559_16; + operand.values[17] = tokenCoding8559_17; + operand.values[18] = tokenCoding8559_18; } -x64Token x64Parser::tokenBranches8549[] = { - {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8550, }, - {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8553, }, +x64Token x64Parser::tokenBranches8555[] = { + {x64Token::REGISTERCLASS, 7, 1, 0, NULL,&x64Parser::TokenFunc8556, }, + {x64Token::REGISTERCLASS, 10, 1, 0, NULL,&x64Parser::TokenFunc8559, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8548[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8549 }, +x64Token x64Parser::tokenBranches8554[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8547[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8548 }, +x64Token x64Parser::tokenBranches8553[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8554 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8557_16[] = { +Coding x64Parser::tokenCoding8563_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_17[] = { +Coding x64Parser::tokenCoding8563_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_23[] = { +Coding x64Parser::tokenCoding8563_23[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_18[] = { +Coding x64Parser::tokenCoding8563_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8557_19[] = { +Coding x64Parser::tokenCoding8563_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8563(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36388,45 +36457,45 @@ void x64Parser::TokenFunc8557(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8557_16; - operand.values[17] = tokenCoding8557_17; - operand.values[23] = tokenCoding8557_23; - operand.values[18] = tokenCoding8557_18; - operand.values[19] = tokenCoding8557_19; + operand.values[16] = tokenCoding8563_16; + operand.values[17] = tokenCoding8563_17; + operand.values[23] = tokenCoding8563_23; + operand.values[18] = tokenCoding8563_18; + operand.values[19] = tokenCoding8563_19; } -x64Token x64Parser::tokenBranches8556[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8557, }, +x64Token x64Parser::tokenBranches8562[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8563, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8555[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8556 }, +x64Token x64Parser::tokenBranches8561[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8562 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8554[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8555 }, +x64Token x64Parser::tokenBranches8560[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8561 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8561_16[] = { +Coding x64Parser::tokenCoding8567_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_17[] = { +Coding x64Parser::tokenCoding8567_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_23[] = { +Coding x64Parser::tokenCoding8567_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_18[] = { +Coding x64Parser::tokenCoding8567_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8561_19[] = { +Coding x64Parser::tokenCoding8567_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36437,45 +36506,45 @@ void x64Parser::TokenFunc8561(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8561_16; - operand.values[17] = tokenCoding8561_17; - operand.values[23] = tokenCoding8561_23; - operand.values[18] = tokenCoding8561_18; - operand.values[19] = tokenCoding8561_19; + operand.values[16] = tokenCoding8567_16; + operand.values[17] = tokenCoding8567_17; + operand.values[23] = tokenCoding8567_23; + operand.values[18] = tokenCoding8567_18; + operand.values[19] = tokenCoding8567_19; } -x64Token x64Parser::tokenBranches8560[] = { - {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8561, }, +x64Token x64Parser::tokenBranches8566[] = { + {x64Token::REGISTERCLASS, 17, 1, 0, NULL,&x64Parser::TokenFunc8567, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8559[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8560 }, +x64Token x64Parser::tokenBranches8565[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8566 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8558[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8559 }, +x64Token x64Parser::tokenBranches8564[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8565 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8565_16[] = { +Coding x64Parser::tokenCoding8571_16[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_17[] = { +Coding x64Parser::tokenCoding8571_17[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_23[] = { +Coding x64Parser::tokenCoding8571_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_18[] = { +Coding x64Parser::tokenCoding8571_18[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8565_19[] = { +Coding x64Parser::tokenCoding8571_19[] = { { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("modreg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8571(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36486,62 +36555,62 @@ void x64Parser::TokenFunc8565(x64Operand &operand, int tokenPos) operand.values[20]->unary = 0; operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; - operand.values[16] = tokenCoding8565_16; - operand.values[17] = tokenCoding8565_17; - operand.values[23] = tokenCoding8565_23; - operand.values[18] = tokenCoding8565_18; - operand.values[19] = tokenCoding8565_19; + operand.values[16] = tokenCoding8571_16; + operand.values[17] = tokenCoding8571_17; + operand.values[23] = tokenCoding8571_23; + operand.values[18] = tokenCoding8571_18; + operand.values[19] = tokenCoding8571_19; } -x64Token x64Parser::tokenBranches8564[] = { - {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8565, }, +x64Token x64Parser::tokenBranches8570[] = { + {x64Token::REGISTERCLASS, 18, 1, 0, NULL,&x64Parser::TokenFunc8571, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8563[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8564 }, +x64Token x64Parser::tokenBranches8569[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8570 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8562[] = { - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8563 }, +x64Token x64Parser::tokenBranches8568[] = { + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8569 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8569_16[] = { +Coding x64Parser::tokenCoding8575_16[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_17[] = { +Coding x64Parser::tokenCoding8575_17[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_23[] = { +Coding x64Parser::tokenCoding8575_23[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_18[] = { +Coding x64Parser::tokenCoding8575_18[] = { { CODING_NAME("reg") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8569_19[] = { +Coding x64Parser::tokenCoding8575_19[] = { { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("reg") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8569(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8575(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8569_16; - operand.values[17] = tokenCoding8569_17; - operand.values[23] = tokenCoding8569_23; - operand.values[18] = tokenCoding8569_18; - operand.values[19] = tokenCoding8569_19; + operand.values[16] = tokenCoding8575_16; + operand.values[17] = tokenCoding8575_17; + operand.values[23] = tokenCoding8575_23; + operand.values[18] = tokenCoding8575_18; + operand.values[19] = tokenCoding8575_19; } -x64Token x64Parser::tokenBranches8568[] = { - {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8569, }, +x64Token x64Parser::tokenBranches8574[] = { + {x64Token::ADDRESSCLASS, 24, 1, 0, NULL,&x64Parser::TokenFunc8575, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8567[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8568 }, +x64Token x64Parser::tokenBranches8573[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8574 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8573(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36553,26 +36622,26 @@ void x64Parser::TokenFunc8567(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8566[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8567, x64Parser::tokenBranches8567 }, +x64Token x64Parser::tokenBranches8572[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8573, x64Parser::tokenBranches8573 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8597_16[] = { +Coding x64Parser::tokenCoding8603_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_17[] = { +Coding x64Parser::tokenCoding8603_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_23[] = { +Coding x64Parser::tokenCoding8603_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8597_18[] = { +Coding x64Parser::tokenCoding8603_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8603(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36585,44 +36654,44 @@ void x64Parser::TokenFunc8597(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8597_16; - operand.values[17] = tokenCoding8597_17; - operand.values[23] = tokenCoding8597_23; - operand.values[18] = tokenCoding8597_18; + operand.values[16] = tokenCoding8603_16; + operand.values[17] = tokenCoding8603_17; + operand.values[23] = tokenCoding8603_23; + operand.values[18] = tokenCoding8603_18; } -x64Token x64Parser::tokenBranches8596[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8597, }, +x64Token x64Parser::tokenBranches8602[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8603, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8595[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8596 }, +x64Token x64Parser::tokenBranches8601[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8602 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8594[] = { - {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8595 }, +x64Token x64Parser::tokenBranches8600[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8593[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8594 }, +x64Token x64Parser::tokenBranches8599[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8602_16[] = { +Coding x64Parser::tokenCoding8608_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_17[] = { +Coding x64Parser::tokenCoding8608_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_23[] = { +Coding x64Parser::tokenCoding8608_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8602_18[] = { +Coding x64Parser::tokenCoding8608_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8608(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36635,28 +36704,28 @@ void x64Parser::TokenFunc8602(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8602_16; - operand.values[17] = tokenCoding8602_17; - operand.values[23] = tokenCoding8602_23; - operand.values[18] = tokenCoding8602_18; + operand.values[16] = tokenCoding8608_16; + operand.values[17] = tokenCoding8608_17; + operand.values[23] = tokenCoding8608_23; + operand.values[18] = tokenCoding8608_18; } -x64Token x64Parser::tokenBranches8601[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8602, }, +x64Token x64Parser::tokenBranches8607[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8608, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8600[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8601 }, +x64Token x64Parser::tokenBranches8606[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8607 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8599[] = { - {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8600 }, +x64Token x64Parser::tokenBranches8605[] = { + {x64Token::ADDRESSCLASS, 9, 0, 0, NULL, NULL, x64Parser::tokenBranches8606 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8598[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8599 }, +x64Token x64Parser::tokenBranches8604[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8605 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8599(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36668,66 +36737,7 @@ void x64Parser::TokenFunc8593(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8598(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8592[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8593, x64Parser::tokenBranches8593 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8598, x64Parser::tokenBranches8598 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8621_16[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::tokenCoding8621_18[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -void x64Parser::TokenFunc8621(x64Operand &operand, int tokenPos) -{ - operand.operandCoding = 468; - operand.values[26] = new Coding[2]; - CleanupValues.push_back(operand.values[26]); - operand.values[26]->type = Coding::number; - operand.values[26]->val = operands.size(); - operand.values[26]->bits = 0; - operand.values[26]->field = 0; - operand.values[26]->unary = 0; - operand.values[26]->binary = 0; - operand.values[26][1].type = Coding::eot; - operands.push_back(numeric); - operand.values[16] = tokenCoding8621_16; - operand.values[17] = tokenCoding8621_17; - operand.values[23] = tokenCoding8621_23; - operand.values[18] = tokenCoding8621_18; -} -x64Token x64Parser::tokenBranches8620[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8621, }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8619[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8620 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8604(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -36739,16 +36749,9 @@ void x64Parser::TokenFunc8619(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8618[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8619, x64Parser::tokenBranches8619 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8617[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8618 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8616[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8617 }, +x64Token x64Parser::tokenBranches8598[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8599, x64Parser::tokenBranches8599 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8604, x64Parser::tokenBranches8604 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8627_16[] = { @@ -36822,7 +36825,7 @@ Coding x64Parser::tokenCoding8633_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8633_23[] = { @@ -36880,7 +36883,7 @@ x64Token x64Parser::tokenBranches8629[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8628[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8629 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8639_16[] = { @@ -36888,21 +36891,17 @@ Coding x64Parser::tokenCoding8639_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8639_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8639_19[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -36920,7 +36919,6 @@ void x64Parser::TokenFunc8639(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8639_17; operand.values[23] = tokenCoding8639_23; operand.values[18] = tokenCoding8639_18; - operand.values[19] = tokenCoding8639_19; } x64Token x64Parser::tokenBranches8638[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8639, }, @@ -36943,35 +36941,38 @@ void x64Parser::TokenFunc8637(x64Operand &operand, int tokenPos) operand.values[20][1].type = Coding::eot; } x64Token x64Parser::tokenBranches8636[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8637, x64Parser::tokenBranches8637 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8635[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8636 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8644_16[] = { +x64Token x64Parser::tokenBranches8634[] = { + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8645_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_17[] = { +Coding x64Parser::tokenCoding8645_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding8645_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_18[] = { +Coding x64Parser::tokenCoding8645_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8644_19[] = { +Coding x64Parser::tokenCoding8645_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -36984,50 +36985,62 @@ void x64Parser::TokenFunc8644(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8644_16; - operand.values[17] = tokenCoding8644_17; - operand.values[23] = tokenCoding8644_23; - operand.values[18] = tokenCoding8644_18; - operand.values[19] = tokenCoding8644_19; + operand.values[16] = tokenCoding8645_16; + operand.values[17] = tokenCoding8645_17; + operand.values[23] = tokenCoding8645_23; + operand.values[18] = tokenCoding8645_18; + operand.values[19] = tokenCoding8645_19; } +x64Token x64Parser::tokenBranches8644[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8645, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8643[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8644, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8644 }, {x64Token::EOT } }; +void x64Parser::TokenFunc8643(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} x64Token x64Parser::tokenBranches8642[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8643 }, + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8643, x64Parser::tokenBranches8643 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8641[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8642 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8640[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, - {x64Token::EOT } -}; -Coding x64Parser::tokenCoding8649_16[] = { +Coding x64Parser::tokenCoding8650_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_17[] = { +Coding x64Parser::tokenCoding8650_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_23[] = { +Coding x64Parser::tokenCoding8650_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_18[] = { +Coding x64Parser::tokenCoding8650_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8649_19[] = { +Coding x64Parser::tokenCoding8650_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8650(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37040,51 +37053,50 @@ void x64Parser::TokenFunc8649(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8649_16; - operand.values[17] = tokenCoding8649_17; - operand.values[23] = tokenCoding8649_23; - operand.values[18] = tokenCoding8649_18; - operand.values[19] = tokenCoding8649_19; + operand.values[16] = tokenCoding8650_16; + operand.values[17] = tokenCoding8650_17; + operand.values[23] = tokenCoding8650_23; + operand.values[18] = tokenCoding8650_18; + operand.values[19] = tokenCoding8650_19; } +x64Token x64Parser::tokenBranches8649[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8650, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8648[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8649, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8649 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8647[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8648 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8646[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8645[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8646 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8647 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8654_16[] = { +Coding x64Parser::tokenCoding8655_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_17[] = { +Coding x64Parser::tokenCoding8655_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_23[] = { +Coding x64Parser::tokenCoding8655_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_18[] = { +Coding x64Parser::tokenCoding8655_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8654_19[] = { +Coding x64Parser::tokenCoding8655_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 197, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8655(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37097,69 +37109,26 @@ void x64Parser::TokenFunc8654(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8654_16; - operand.values[17] = tokenCoding8654_17; - operand.values[23] = tokenCoding8654_23; - operand.values[18] = tokenCoding8654_18; - operand.values[19] = tokenCoding8654_19; + operand.values[16] = tokenCoding8655_16; + operand.values[17] = tokenCoding8655_17; + operand.values[23] = tokenCoding8655_23; + operand.values[18] = tokenCoding8655_18; + operand.values[19] = tokenCoding8655_19; } +x64Token x64Parser::tokenBranches8654[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8655, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8653[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8654, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8654 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8652[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8653 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8652(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} x64Token x64Parser::tokenBranches8651[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8652, x64Parser::tokenBranches8652 }, - {x64Token::EOT } -}; -x64Token x64Parser::tokenBranches8650[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8651 }, - {x64Token::EOT } -}; -void x64Parser::TokenFunc8640(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -void x64Parser::TokenFunc8645(x64Operand &operand, int tokenPos) -{ - operand.values[20] = new Coding[2]; - CleanupValues.push_back(operand.values[20]); - operand.values[20]->type = Coding::reg; - operand.values[20]->val = inputTokens[tokenPos]->val->ival; - operand.values[20]->bits = 0; - operand.values[20]->field = 0; - operand.values[20]->unary = 0; - operand.values[20]->binary = 0; - operand.values[20][1].type = Coding::eot; -} -x64Token x64Parser::tokenBranches8634[] = { - {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8635 }, - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8640, x64Parser::tokenBranches8640 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8645, x64Parser::tokenBranches8645 }, - {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8650 }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8652 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8660_16[] = { @@ -37178,6 +37147,12 @@ Coding x64Parser::tokenCoding8660_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; +Coding x64Parser::tokenCoding8660_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -37195,6 +37170,7 @@ void x64Parser::TokenFunc8660(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8660_17; operand.values[23] = tokenCoding8660_23; operand.values[18] = tokenCoding8660_18; + operand.values[19] = tokenCoding8660_19; } x64Token x64Parser::tokenBranches8659[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8660, }, @@ -37204,15 +37180,27 @@ x64Token x64Parser::tokenBranches8658[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8659 }, {x64Token::EOT } }; +void x64Parser::TokenFunc8658(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} x64Token x64Parser::tokenBranches8657[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8658 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8658, x64Parser::tokenBranches8658 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8656[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8657 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8646(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37224,8 +37212,23 @@ void x64Parser::TokenFunc8656(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8655[] = { - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8656, x64Parser::tokenBranches8656 }, +void x64Parser::TokenFunc8651(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8640[] = { + {x64Token::ADDRESSCLASS, 19, 0, 0, NULL, NULL, x64Parser::tokenBranches8641 }, + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8646, x64Parser::tokenBranches8646 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8651, x64Parser::tokenBranches8651 }, + {x64Token::ADDRESSCLASS, 1, 0, 0, NULL, NULL, x64Parser::tokenBranches8656 }, {x64Token::EOT } }; Coding x64Parser::tokenCoding8666_16[] = { @@ -37299,7 +37302,7 @@ Coding x64Parser::tokenCoding8672_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8672_23[] = { @@ -37337,7 +37340,7 @@ x64Token x64Parser::tokenBranches8670[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8669[] = { - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8670 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8668[] = { @@ -37365,21 +37368,17 @@ Coding x64Parser::tokenCoding8678_16[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::tokenCoding8678_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8678_19[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; @@ -37397,7 +37396,6 @@ void x64Parser::TokenFunc8678(x64Operand &operand, int tokenPos) operand.values[17] = tokenCoding8678_17; operand.values[23] = tokenCoding8678_23; operand.values[18] = tokenCoding8678_18; - operand.values[19] = tokenCoding8678_19; } x64Token x64Parser::tokenBranches8677[] = { {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8678, }, @@ -37408,35 +37406,50 @@ x64Token x64Parser::tokenBranches8676[] = { {x64Token::EOT } }; x64Token x64Parser::tokenBranches8675[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8676 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8674[] = { {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8675 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8683_16[] = { +void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +{ + operand.values[20] = new Coding[2]; + CleanupValues.push_back(operand.values[20]); + operand.values[20]->type = Coding::reg; + operand.values[20]->val = inputTokens[tokenPos]->val->ival; + operand.values[20]->bits = 0; + operand.values[20]->field = 0; + operand.values[20]->unary = 0; + operand.values[20]->binary = 0; + operand.values[20][1].type = Coding::eot; +} +x64Token x64Parser::tokenBranches8673[] = { + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8684_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_17[] = { +Coding x64Parser::tokenCoding8684_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_23[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::tokenCoding8684_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_18[] = { +Coding x64Parser::tokenCoding8684_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8683_19[] = { +Coding x64Parser::tokenCoding8684_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8684(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37449,42 +37462,50 @@ void x64Parser::TokenFunc8683(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8683_16; - operand.values[17] = tokenCoding8683_17; - operand.values[23] = tokenCoding8683_23; - operand.values[18] = tokenCoding8683_18; - operand.values[19] = tokenCoding8683_19; + operand.values[16] = tokenCoding8684_16; + operand.values[17] = tokenCoding8684_17; + operand.values[23] = tokenCoding8684_23; + operand.values[18] = tokenCoding8684_18; + operand.values[19] = tokenCoding8684_19; } +x64Token x64Parser::tokenBranches8683[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8684, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8682[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8683, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8683 }, {x64Token::EOT } }; x64Token x64Parser::tokenBranches8681[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8682 }, + {x64Token::EOT } +}; +x64Token x64Parser::tokenBranches8680[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8688_16[] = { +Coding x64Parser::tokenCoding8689_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_17[] = { - { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, +Coding x64Parser::tokenCoding8689_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_23[] = { +Coding x64Parser::tokenCoding8689_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_18[] = { +Coding x64Parser::tokenCoding8689_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8688_19[] = { +Coding x64Parser::tokenCoding8689_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8689(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37497,42 +37518,90 @@ void x64Parser::TokenFunc8688(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8688_16; - operand.values[17] = tokenCoding8688_17; - operand.values[23] = tokenCoding8688_23; - operand.values[18] = tokenCoding8688_18; - operand.values[19] = tokenCoding8688_19; + operand.values[16] = tokenCoding8689_16; + operand.values[17] = tokenCoding8689_17; + operand.values[23] = tokenCoding8689_23; + operand.values[18] = tokenCoding8689_18; + operand.values[19] = tokenCoding8689_19; } +x64Token x64Parser::tokenBranches8688[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8689, }, + {x64Token::EOT } +}; x64Token x64Parser::tokenBranches8687[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8688, }, + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8688 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8686[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, +Coding x64Parser::tokenCoding8694_16[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_17[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_23[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_18[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::tokenCoding8694_19[] = { + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +void x64Parser::TokenFunc8694(x64Operand &operand, int tokenPos) +{ + operand.operandCoding = 468; + operand.values[26] = new Coding[2]; + CleanupValues.push_back(operand.values[26]); + operand.values[26]->type = Coding::number; + operand.values[26]->val = operands.size(); + operand.values[26]->bits = 0; + operand.values[26]->field = 0; + operand.values[26]->unary = 0; + operand.values[26]->binary = 0; + operand.values[26][1].type = Coding::eot; + operands.push_back(numeric); + operand.values[16] = tokenCoding8694_16; + operand.values[17] = tokenCoding8694_17; + operand.values[23] = tokenCoding8694_23; + operand.values[18] = tokenCoding8694_18; + operand.values[19] = tokenCoding8694_19; +} +x64Token x64Parser::tokenBranches8693[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8694, }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8693_16[] = { +x64Token x64Parser::tokenBranches8692[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8693 }, + {x64Token::EOT } +}; +Coding x64Parser::tokenCoding8699_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_17[] = { +Coding x64Parser::tokenCoding8699_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_23[] = { +Coding x64Parser::tokenCoding8699_23[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_18[] = { +Coding x64Parser::tokenCoding8699_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8693_19[] = { +Coding x64Parser::tokenCoding8699_19[] = { { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("imm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8699(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37545,31 +37614,31 @@ void x64Parser::TokenFunc8693(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8693_16; - operand.values[17] = tokenCoding8693_17; - operand.values[23] = tokenCoding8693_23; - operand.values[18] = tokenCoding8693_18; - operand.values[19] = tokenCoding8693_19; + operand.values[16] = tokenCoding8699_16; + operand.values[17] = tokenCoding8699_17; + operand.values[23] = tokenCoding8699_23; + operand.values[18] = tokenCoding8699_18; + operand.values[19] = tokenCoding8699_19; } -x64Token x64Parser::tokenBranches8692[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8693, }, +x64Token x64Parser::tokenBranches8698[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8699, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8691[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, +x64Token x64Parser::tokenBranches8697[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8698 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8680[] = { - {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8681 }, - {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, - {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8691 }, +x64Token x64Parser::tokenBranches8686[] = { + {x64Token::ADDRESSCLASS, 5, 0, 0, NULL, NULL, x64Parser::tokenBranches8687 }, + {x64Token::ADDRESSCLASS, 21, 0, 0, NULL, NULL, x64Parser::tokenBranches8692 }, + {x64Token::ADDRESSCLASS, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8697 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8679[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8680 }, +x64Token x64Parser::tokenBranches8685[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8686 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8680(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37581,7 +37650,7 @@ void x64Parser::TokenFunc8674(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8685(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37593,120 +37662,120 @@ void x64Parser::TokenFunc8679(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8673[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8674, x64Parser::tokenBranches8674 }, - {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8679, x64Parser::tokenBranches8679 }, +x64Token x64Parser::tokenBranches8679[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8680, x64Parser::tokenBranches8680 }, + {x64Token::REGISTERCLASS, 17, 0, 0, NULL,&x64Parser::TokenFunc8685, x64Parser::tokenBranches8685 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8702_16[] = { +Coding x64Parser::tokenCoding8708_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_17[] = { +Coding x64Parser::tokenCoding8708_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_23[] = { +Coding x64Parser::tokenCoding8708_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8702_18[] = { +Coding x64Parser::tokenCoding8708_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8702(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8702_16; - operand.values[17] = tokenCoding8702_17; - operand.values[23] = tokenCoding8702_23; - operand.values[18] = tokenCoding8702_18; + operand.values[16] = tokenCoding8708_16; + operand.values[17] = tokenCoding8708_17; + operand.values[23] = tokenCoding8708_23; + operand.values[18] = tokenCoding8708_18; } -Coding x64Parser::tokenCoding8708_16[] = { +Coding x64Parser::tokenCoding8714_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_17[] = { +Coding x64Parser::tokenCoding8714_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_23[] = { +Coding x64Parser::tokenCoding8714_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8708_18[] = { +Coding x64Parser::tokenCoding8714_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8708(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8714(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8708_16; - operand.values[17] = tokenCoding8708_17; - operand.values[23] = tokenCoding8708_23; - operand.values[18] = tokenCoding8708_18; + operand.values[16] = tokenCoding8714_16; + operand.values[17] = tokenCoding8714_17; + operand.values[23] = tokenCoding8714_23; + operand.values[18] = tokenCoding8714_18; } -x64Token x64Parser::tokenBranches8701[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8702, }, - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8708, }, +x64Token x64Parser::tokenBranches8707[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8708, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8714, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8700[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8701 }, +x64Token x64Parser::tokenBranches8706[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8707 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8705_16[] = { +Coding x64Parser::tokenCoding8711_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_17[] = { +Coding x64Parser::tokenCoding8711_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_23[] = { +Coding x64Parser::tokenCoding8711_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8705_18[] = { +Coding x64Parser::tokenCoding8711_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8705(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8705_16; - operand.values[17] = tokenCoding8705_17; - operand.values[23] = tokenCoding8705_23; - operand.values[18] = tokenCoding8705_18; + operand.values[16] = tokenCoding8711_16; + operand.values[17] = tokenCoding8711_17; + operand.values[23] = tokenCoding8711_23; + operand.values[18] = tokenCoding8711_18; } -Coding x64Parser::tokenCoding8711_16[] = { +Coding x64Parser::tokenCoding8717_16[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_17[] = { +Coding x64Parser::tokenCoding8717_17[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_23[] = { +Coding x64Parser::tokenCoding8717_23[] = { { CODING_NAME("rm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8711_18[] = { +Coding x64Parser::tokenCoding8717_18[] = { { CODING_NAME("rm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8711(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8717(x64Operand &operand, int tokenPos) { - operand.values[16] = tokenCoding8711_16; - operand.values[17] = tokenCoding8711_17; - operand.values[23] = tokenCoding8711_23; - operand.values[18] = tokenCoding8711_18; + operand.values[16] = tokenCoding8717_16; + operand.values[17] = tokenCoding8717_17; + operand.values[23] = tokenCoding8717_23; + operand.values[18] = tokenCoding8717_18; } -x64Token x64Parser::tokenBranches8704[] = { - {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8705, }, - {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8711, }, +x64Token x64Parser::tokenBranches8710[] = { + {x64Token::ADDRESSCLASS, 8, 1, 0, NULL,&x64Parser::TokenFunc8711, }, + {x64Token::ADDRESSCLASS, 9, 1, 0, NULL,&x64Parser::TokenFunc8717, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8703[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8704 }, +x64Token x64Parser::tokenBranches8709[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8710 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8706(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37718,7 +37787,7 @@ void x64Parser::TokenFunc8700(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8709(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37730,24 +37799,24 @@ void x64Parser::TokenFunc8703(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8699[] = { - {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8700, x64Parser::tokenBranches8700 }, - {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8703, x64Parser::tokenBranches8703 }, +x64Token x64Parser::tokenBranches8705[] = { + {x64Token::REGISTERCLASS, 7, 0, 0, NULL,&x64Parser::TokenFunc8706, x64Parser::tokenBranches8706 }, + {x64Token::REGISTERCLASS, 10, 0, 0, NULL,&x64Parser::TokenFunc8709, x64Parser::tokenBranches8709 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8725_16[] = { +Coding x64Parser::tokenCoding8731_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8725_17[] = { +Coding x64Parser::tokenCoding8731_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 3, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8725_18[] = { +Coding x64Parser::tokenCoding8731_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8731(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37760,27 +37829,27 @@ void x64Parser::TokenFunc8725(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8725_16; - operand.values[17] = tokenCoding8725_17; - operand.values[18] = tokenCoding8725_18; + operand.values[16] = tokenCoding8731_16; + operand.values[17] = tokenCoding8731_17; + operand.values[18] = tokenCoding8731_18; } -x64Token x64Parser::tokenBranches8724[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8725, }, +x64Token x64Parser::tokenBranches8730[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8731, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8723[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8724 }, +x64Token x64Parser::tokenBranches8729[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8730 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8722[] = { - {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8723 }, +x64Token x64Parser::tokenBranches8728[] = { + {x64Token::ADDRESSCLASS, 8, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8721[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8722 }, +x64Token x64Parser::tokenBranches8727[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, {x64Token::EOT } }; -void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8727(x64Operand &operand, int tokenPos) { operand.values[20] = new Coding[2]; CleanupValues.push_back(operand.values[20]); @@ -37792,23 +37861,23 @@ void x64Parser::TokenFunc8721(x64Operand &operand, int tokenPos) operand.values[20]->binary = 0; operand.values[20][1].type = Coding::eot; } -x64Token x64Parser::tokenBranches8720[] = { - {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8721, x64Parser::tokenBranches8721 }, +x64Token x64Parser::tokenBranches8726[] = { + {x64Token::REGISTERCLASS, 18, 0, 0, NULL,&x64Parser::TokenFunc8727, x64Parser::tokenBranches8727 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8730_16[] = { +Coding x64Parser::tokenCoding8736_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8730_17[] = { +Coding x64Parser::tokenCoding8736_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8730_18[] = { +Coding x64Parser::tokenCoding8736_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8736(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37821,35 +37890,35 @@ void x64Parser::TokenFunc8730(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8730_16; - operand.values[17] = tokenCoding8730_17; - operand.values[18] = tokenCoding8730_18; + operand.values[16] = tokenCoding8736_16; + operand.values[17] = tokenCoding8736_17; + operand.values[18] = tokenCoding8736_18; } -x64Token x64Parser::tokenBranches8729[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8730, }, +x64Token x64Parser::tokenBranches8735[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8736, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8728[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8729 }, +x64Token x64Parser::tokenBranches8734[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8735 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8727[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8728 }, +x64Token x64Parser::tokenBranches8733[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8734 }, {x64Token::EOT } }; -Coding x64Parser::tokenCoding8739_16[] = { +Coding x64Parser::tokenCoding8745_16[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8739_17[] = { +Coding x64Parser::tokenCoding8745_17[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::tokenCoding8739_18[] = { +Coding x64Parser::tokenCoding8745_18[] = { { CODING_NAME("imm") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) +void x64Parser::TokenFunc8745(x64Operand &operand, int tokenPos) { operand.operandCoding = 468; operand.values[26] = new Coding[2]; @@ -37862,20 +37931,20 @@ void x64Parser::TokenFunc8739(x64Operand &operand, int tokenPos) operand.values[26]->binary = 0; operand.values[26][1].type = Coding::eot; operands.push_back(numeric); - operand.values[16] = tokenCoding8739_16; - operand.values[17] = tokenCoding8739_17; - operand.values[18] = tokenCoding8739_18; + operand.values[16] = tokenCoding8745_16; + operand.values[17] = tokenCoding8745_17; + operand.values[18] = tokenCoding8745_18; } -x64Token x64Parser::tokenBranches8738[] = { - {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8739, }, +x64Token x64Parser::tokenBranches8744[] = { + {x64Token::NUMBER, 3, 1, 0, NULL,&x64Parser::TokenFunc8745, }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8737[] = { - {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8738 }, +x64Token x64Parser::tokenBranches8743[] = { + {x64Token::TOKEN, 7, 0, 0, NULL, NULL, x64Parser::tokenBranches8744 }, {x64Token::EOT } }; -x64Token x64Parser::tokenBranches8736[] = { - {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8737 }, +x64Token x64Parser::tokenBranches8742[] = { + {x64Token::ADDRESSCLASS, 27, 0, 0, NULL, NULL, x64Parser::tokenBranches8743 }, {x64Token::EOT } }; asmError x64Parser::Opcode0(x64Operand &operand) @@ -38923,1166 +38992,1166 @@ asmError x64Parser::Opcode97(x64Operand &operand) asmError rv = ParseOperands(tokenBranches6245, operand); return rv; } -Coding x64Parser::OpcodeCodings98_19[] = { +asmError x64Parser::Opcode98(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6248, operand); + return rv; +} +asmError x64Parser::Opcode99(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6251, operand); + return rv; +} +Coding x64Parser::OpcodeCodings100_19[] = { { CODING_NAME("cwd") Coding::stateFunc, 4 }, { CODING_NAME("cwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode98(x64Operand &operand) +asmError x64Parser::Opcode100(x64Operand &operand) { - operand.values[19] = OpcodeCodings98_19; + operand.values[19] = OpcodeCodings100_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings99_19[] = { +Coding x64Parser::OpcodeCodings101_19[] = { { CODING_NAME("cwde") Coding::stateFunc, 5 }, { CODING_NAME("cwde") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 152, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode99(x64Operand &operand) +asmError x64Parser::Opcode101(x64Operand &operand) { - operand.values[19] = OpcodeCodings99_19; + operand.values[19] = OpcodeCodings101_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings100_19[] = { +Coding x64Parser::OpcodeCodings102_19[] = { { CODING_NAME("daa") Coding::stateFunc, 7 }, { CODING_NAME("daa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 39, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode100(x64Operand &operand) +asmError x64Parser::Opcode102(x64Operand &operand) { - operand.values[19] = OpcodeCodings100_19; + operand.values[19] = OpcodeCodings102_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings101_19[] = { +Coding x64Parser::OpcodeCodings103_19[] = { { CODING_NAME("das") Coding::stateFunc, 7 }, { CODING_NAME("das") (Coding::Type)(Coding::valSpecified), 47, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode101(x64Operand &operand) +asmError x64Parser::Opcode103(x64Operand &operand) { - operand.values[19] = OpcodeCodings101_19; + operand.values[19] = OpcodeCodings103_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings102_18[] = { +Coding x64Parser::OpcodeCodings104_18[] = { { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings102_19[] = { +Coding x64Parser::OpcodeCodings104_19[] = { { CODING_NAME("dec") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode102(x64Operand &operand) +asmError x64Parser::Opcode104(x64Operand &operand) { - operand.values[18] = OpcodeCodings102_18; - operand.values[19] = OpcodeCodings102_19; + operand.values[18] = OpcodeCodings104_18; + operand.values[19] = OpcodeCodings104_19; asmError rv; { rv = Opcode6(operand); } return rv; } -Coding x64Parser::OpcodeCodings103_18[] = { +Coding x64Parser::OpcodeCodings105_18[] = { { CODING_NAME("div") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode103(x64Operand &operand) +asmError x64Parser::Opcode105(x64Operand &operand) { - operand.values[18] = OpcodeCodings103_18; + operand.values[18] = OpcodeCodings105_18; asmError rv; { rv = Opcode7(operand); } return rv; } -asmError x64Parser::Opcode104(x64Operand &operand) +asmError x64Parser::Opcode106(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6253, operand); + asmError rv = ParseOperands(tokenBranches6259, operand); return rv; } -asmError x64Parser::Opcode105(x64Operand &operand) +asmError x64Parser::Opcode107(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6259, operand); + asmError rv = ParseOperands(tokenBranches6265, operand); return rv; } -Coding x64Parser::OpcodeCodings106_19[] = { +Coding x64Parser::OpcodeCodings108_19[] = { { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("f2xm1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode106(x64Operand &operand) +asmError x64Parser::Opcode108(x64Operand &operand) { - operand.values[19] = OpcodeCodings106_19; + operand.values[19] = OpcodeCodings108_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings107_19[] = { +Coding x64Parser::OpcodeCodings109_19[] = { { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fabs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode107(x64Operand &operand) +asmError x64Parser::Opcode109(x64Operand &operand) { - operand.values[19] = OpcodeCodings107_19; + operand.values[19] = OpcodeCodings109_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings108_18[] = { +Coding x64Parser::OpcodeCodings110_18[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings108_39[] = { +Coding x64Parser::OpcodeCodings110_39[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings108_36[] = { +Coding x64Parser::OpcodeCodings110_36[] = { { CODING_NAME("fadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode108(x64Operand &operand) +asmError x64Parser::Opcode110(x64Operand &operand) { - operand.values[18] = OpcodeCodings108_18; - operand.values[39] = OpcodeCodings108_39; - operand.values[36] = OpcodeCodings108_36; + operand.values[18] = OpcodeCodings110_18; + operand.values[39] = OpcodeCodings110_39; + operand.values[36] = OpcodeCodings110_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings109_18[] = { +Coding x64Parser::OpcodeCodings111_18[] = { { CODING_NAME("faddp") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings109_19[] = { +Coding x64Parser::OpcodeCodings111_19[] = { { CODING_NAME("faddp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode109(x64Operand &operand) +asmError x64Parser::Opcode111(x64Operand &operand) { - operand.values[18] = OpcodeCodings109_18; - operand.values[19] = OpcodeCodings109_19; + operand.values[18] = OpcodeCodings111_18; + operand.values[19] = OpcodeCodings111_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings110_18[] = { +Coding x64Parser::OpcodeCodings112_18[] = { { CODING_NAME("fbld") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings110_19[] = { +Coding x64Parser::OpcodeCodings112_19[] = { { CODING_NAME("fbld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode110(x64Operand &operand) +asmError x64Parser::Opcode112(x64Operand &operand) { - operand.values[18] = OpcodeCodings110_18; - operand.values[19] = OpcodeCodings110_19; + operand.values[18] = OpcodeCodings112_18; + operand.values[19] = OpcodeCodings112_19; asmError rv; { rv = Opcode11(operand); } return rv; } -Coding x64Parser::OpcodeCodings111_18[] = { +Coding x64Parser::OpcodeCodings113_18[] = { { CODING_NAME("fbstp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings111_19[] = { +Coding x64Parser::OpcodeCodings113_19[] = { { CODING_NAME("fbstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode111(x64Operand &operand) +asmError x64Parser::Opcode113(x64Operand &operand) { - operand.values[18] = OpcodeCodings111_18; - operand.values[19] = OpcodeCodings111_19; + operand.values[18] = OpcodeCodings113_18; + operand.values[19] = OpcodeCodings113_19; asmError rv; { rv = Opcode11(operand); } return rv; } -Coding x64Parser::OpcodeCodings112_19[] = { +Coding x64Parser::OpcodeCodings114_19[] = { { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fchs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode112(x64Operand &operand) +asmError x64Parser::Opcode114(x64Operand &operand) { - operand.values[19] = OpcodeCodings112_19; + operand.values[19] = OpcodeCodings114_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings113_19[] = { +Coding x64Parser::OpcodeCodings115_19[] = { { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode113(x64Operand &operand) +asmError x64Parser::Opcode115(x64Operand &operand) { - operand.values[19] = OpcodeCodings113_19; + operand.values[19] = OpcodeCodings115_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings114_19[] = { +Coding x64Parser::OpcodeCodings116_19[] = { { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fnclex") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode114(x64Operand &operand) +asmError x64Parser::Opcode116(x64Operand &operand) { - operand.values[19] = OpcodeCodings114_19; + operand.values[19] = OpcodeCodings116_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings115_18[] = { - { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings115_36[] = { - { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode115(x64Operand &operand) -{ - operand.values[18] = OpcodeCodings115_18; - operand.values[36] = OpcodeCodings115_36; - asmError rv = ParseOperands(tokenBranches6272, operand); - return rv; -} -Coding x64Parser::OpcodeCodings116_18[] = { - { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings116_36[] = { - { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode116(x64Operand &operand) -{ - operand.values[18] = OpcodeCodings116_18; - operand.values[36] = OpcodeCodings116_36; - asmError rv = ParseOperands(tokenBranches6276, operand); - return rv; -} Coding x64Parser::OpcodeCodings117_18[] = { - { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings117_36[] = { - { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fcmovb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode117(x64Operand &operand) { operand.values[18] = OpcodeCodings117_18; operand.values[36] = OpcodeCodings117_36; - asmError rv = ParseOperands(tokenBranches6280, operand); + asmError rv = ParseOperands(tokenBranches6278, operand); return rv; } Coding x64Parser::OpcodeCodings118_18[] = { - { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings118_36[] = { - { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode118(x64Operand &operand) { operand.values[18] = OpcodeCodings118_18; operand.values[36] = OpcodeCodings118_36; - asmError rv = ParseOperands(tokenBranches6284, operand); + asmError rv = ParseOperands(tokenBranches6282, operand); return rv; } Coding x64Parser::OpcodeCodings119_18[] = { - { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("fcmove") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings119_36[] = { - { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmove") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode119(x64Operand &operand) { operand.values[18] = OpcodeCodings119_18; operand.values[36] = OpcodeCodings119_36; - asmError rv = ParseOperands(tokenBranches6288, operand); + asmError rv = ParseOperands(tokenBranches6286, operand); return rv; } Coding x64Parser::OpcodeCodings120_18[] = { - { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings120_36[] = { - { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode120(x64Operand &operand) { operand.values[18] = OpcodeCodings120_18; operand.values[36] = OpcodeCodings120_36; - asmError rv = ParseOperands(tokenBranches6292, operand); + asmError rv = ParseOperands(tokenBranches6290, operand); return rv; } Coding x64Parser::OpcodeCodings121_18[] = { - { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings121_36[] = { - { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode121(x64Operand &operand) { operand.values[18] = OpcodeCodings121_18; operand.values[36] = OpcodeCodings121_36; - asmError rv = ParseOperands(tokenBranches6296, operand); + asmError rv = ParseOperands(tokenBranches6294, operand); return rv; } Coding x64Parser::OpcodeCodings122_18[] = { - { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings122_36[] = { - { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("fcmovne") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode122(x64Operand &operand) { operand.values[18] = OpcodeCodings122_18; operand.values[36] = OpcodeCodings122_36; - asmError rv = ParseOperands(tokenBranches6300, operand); + asmError rv = ParseOperands(tokenBranches6298, operand); return rv; } Coding x64Parser::OpcodeCodings123_18[] = { - { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings123_36[] = { - { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("fcmovnu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode123(x64Operand &operand) { operand.values[18] = OpcodeCodings123_18; operand.values[36] = OpcodeCodings123_36; - asmError rv = ParseOperands(tokenBranches6304, operand); + asmError rv = ParseOperands(tokenBranches6302, operand); return rv; } Coding x64Parser::OpcodeCodings124_18[] = { - { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings124_36[] = { - { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, + { CODING_NAME("fcmovu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode124(x64Operand &operand) { operand.values[18] = OpcodeCodings124_18; operand.values[36] = OpcodeCodings124_36; - asmError rv = ParseOperands(tokenBranches6313, operand); + asmError rv = ParseOperands(tokenBranches6306, operand); return rv; } Coding x64Parser::OpcodeCodings125_18[] = { - { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("fcom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings125_36[] = { - { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("fcom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode125(x64Operand &operand) { operand.values[18] = OpcodeCodings125_18; operand.values[36] = OpcodeCodings125_36; - asmError rv = ParseOperands(tokenBranches6317, operand); + asmError rv = ParseOperands(tokenBranches6310, operand); return rv; } Coding x64Parser::OpcodeCodings126_18[] = { - { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("fcomi") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings126_36[] = { - { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("fcomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode126(x64Operand &operand) { operand.values[18] = OpcodeCodings126_18; operand.values[36] = OpcodeCodings126_36; - asmError rv = ParseOperands(tokenBranches6321, operand); + asmError rv = ParseOperands(tokenBranches6319, operand); + return rv; +} +Coding x64Parser::OpcodeCodings127_18[] = { + { CODING_NAME("fcomip") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings127_36[] = { + { CODING_NAME("fcomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode127(x64Operand &operand) +{ + operand.values[18] = OpcodeCodings127_18; + operand.values[36] = OpcodeCodings127_36; + asmError rv = ParseOperands(tokenBranches6323, operand); + return rv; +} +Coding x64Parser::OpcodeCodings128_18[] = { + { CODING_NAME("fcomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings128_36[] = { + { CODING_NAME("fcomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode128(x64Operand &operand) +{ + operand.values[18] = OpcodeCodings128_18; + operand.values[36] = OpcodeCodings128_36; + asmError rv = ParseOperands(tokenBranches6327, operand); return rv; } -Coding x64Parser::OpcodeCodings127_19[] = { +Coding x64Parser::OpcodeCodings129_19[] = { { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("fcompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode127(x64Operand &operand) +asmError x64Parser::Opcode129(x64Operand &operand) { - operand.values[19] = OpcodeCodings127_19; + operand.values[19] = OpcodeCodings129_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings128_19[] = { +Coding x64Parser::OpcodeCodings130_19[] = { { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fcos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 255, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode128(x64Operand &operand) +asmError x64Parser::Opcode130(x64Operand &operand) { - operand.values[19] = OpcodeCodings128_19; + operand.values[19] = OpcodeCodings130_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings129_19[] = { +Coding x64Parser::OpcodeCodings131_19[] = { { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fdecstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode129(x64Operand &operand) +asmError x64Parser::Opcode131(x64Operand &operand) { - operand.values[19] = OpcodeCodings129_19; + operand.values[19] = OpcodeCodings131_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings130_19[] = { +Coding x64Parser::OpcodeCodings132_19[] = { { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fdisi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode130(x64Operand &operand) +asmError x64Parser::Opcode132(x64Operand &operand) { - operand.values[19] = OpcodeCodings130_19; + operand.values[19] = OpcodeCodings132_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings131_18[] = { +Coding x64Parser::OpcodeCodings133_18[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings131_39[] = { +Coding x64Parser::OpcodeCodings133_39[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings131_36[] = { +Coding x64Parser::OpcodeCodings133_36[] = { { CODING_NAME("fdiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode131(x64Operand &operand) +asmError x64Parser::Opcode133(x64Operand &operand) { - operand.values[18] = OpcodeCodings131_18; - operand.values[39] = OpcodeCodings131_39; - operand.values[36] = OpcodeCodings131_36; + operand.values[18] = OpcodeCodings133_18; + operand.values[39] = OpcodeCodings133_39; + operand.values[36] = OpcodeCodings133_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings132_18[] = { +Coding x64Parser::OpcodeCodings134_18[] = { { CODING_NAME("fdivp") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings132_19[] = { +Coding x64Parser::OpcodeCodings134_19[] = { { CODING_NAME("fdivp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode132(x64Operand &operand) +asmError x64Parser::Opcode134(x64Operand &operand) { - operand.values[18] = OpcodeCodings132_18; - operand.values[19] = OpcodeCodings132_19; + operand.values[18] = OpcodeCodings134_18; + operand.values[19] = OpcodeCodings134_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings133_18[] = { +Coding x64Parser::OpcodeCodings135_18[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings133_39[] = { +Coding x64Parser::OpcodeCodings135_39[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings133_36[] = { +Coding x64Parser::OpcodeCodings135_36[] = { { CODING_NAME("fdivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode133(x64Operand &operand) +asmError x64Parser::Opcode135(x64Operand &operand) { - operand.values[18] = OpcodeCodings133_18; - operand.values[39] = OpcodeCodings133_39; - operand.values[36] = OpcodeCodings133_36; + operand.values[18] = OpcodeCodings135_18; + operand.values[39] = OpcodeCodings135_39; + operand.values[36] = OpcodeCodings135_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings134_18[] = { +Coding x64Parser::OpcodeCodings136_18[] = { { CODING_NAME("fdivrp") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings134_19[] = { +Coding x64Parser::OpcodeCodings136_19[] = { { CODING_NAME("fdivrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode134(x64Operand &operand) +asmError x64Parser::Opcode136(x64Operand &operand) { - operand.values[18] = OpcodeCodings134_18; - operand.values[19] = OpcodeCodings134_19; + operand.values[18] = OpcodeCodings136_18; + operand.values[19] = OpcodeCodings136_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings135_19[] = { +Coding x64Parser::OpcodeCodings137_19[] = { { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("feni") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode135(x64Operand &operand) +asmError x64Parser::Opcode137(x64Operand &operand) { - operand.values[19] = OpcodeCodings135_19; + operand.values[19] = OpcodeCodings137_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode136(x64Operand &operand) +asmError x64Parser::Opcode138(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6336, operand); + asmError rv = ParseOperands(tokenBranches6342, operand); return rv; } -asmError x64Parser::Opcode137(x64Operand &operand) +asmError x64Parser::Opcode139(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6338, operand); + asmError rv = ParseOperands(tokenBranches6344, operand); return rv; } -Coding x64Parser::OpcodeCodings138_18[] = { +Coding x64Parser::OpcodeCodings140_18[] = { { CODING_NAME("fiadd") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings138_36[] = { +Coding x64Parser::OpcodeCodings140_36[] = { { CODING_NAME("fiadd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode138(x64Operand &operand) +asmError x64Parser::Opcode140(x64Operand &operand) { - operand.values[18] = OpcodeCodings138_18; - operand.values[36] = OpcodeCodings138_36; + operand.values[18] = OpcodeCodings140_18; + operand.values[36] = OpcodeCodings140_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings139_18[] = { +Coding x64Parser::OpcodeCodings141_18[] = { { CODING_NAME("ficom") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings139_36[] = { +Coding x64Parser::OpcodeCodings141_36[] = { { CODING_NAME("ficom") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode139(x64Operand &operand) +asmError x64Parser::Opcode141(x64Operand &operand) { - operand.values[18] = OpcodeCodings139_18; - operand.values[36] = OpcodeCodings139_36; + operand.values[18] = OpcodeCodings141_18; + operand.values[36] = OpcodeCodings141_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings140_18[] = { +Coding x64Parser::OpcodeCodings142_18[] = { { CODING_NAME("ficomp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings140_36[] = { +Coding x64Parser::OpcodeCodings142_36[] = { { CODING_NAME("ficomp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode140(x64Operand &operand) +asmError x64Parser::Opcode142(x64Operand &operand) { - operand.values[18] = OpcodeCodings140_18; - operand.values[36] = OpcodeCodings140_36; + operand.values[18] = OpcodeCodings142_18; + operand.values[36] = OpcodeCodings142_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings141_18[] = { +Coding x64Parser::OpcodeCodings143_18[] = { { CODING_NAME("fidiv") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings141_36[] = { +Coding x64Parser::OpcodeCodings143_36[] = { { CODING_NAME("fidiv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode141(x64Operand &operand) +asmError x64Parser::Opcode143(x64Operand &operand) { - operand.values[18] = OpcodeCodings141_18; - operand.values[36] = OpcodeCodings141_36; + operand.values[18] = OpcodeCodings143_18; + operand.values[36] = OpcodeCodings143_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings142_18[] = { +Coding x64Parser::OpcodeCodings144_18[] = { { CODING_NAME("fidivr") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings142_36[] = { +Coding x64Parser::OpcodeCodings144_36[] = { { CODING_NAME("fidivr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode142(x64Operand &operand) +asmError x64Parser::Opcode144(x64Operand &operand) { - operand.values[18] = OpcodeCodings142_18; - operand.values[36] = OpcodeCodings142_36; + operand.values[18] = OpcodeCodings144_18; + operand.values[36] = OpcodeCodings144_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings143_18[] = { +Coding x64Parser::OpcodeCodings145_18[] = { { CODING_NAME("fild") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings143_36[] = { +Coding x64Parser::OpcodeCodings145_36[] = { { CODING_NAME("fild") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode143(x64Operand &operand) +asmError x64Parser::Opcode145(x64Operand &operand) { - operand.values[18] = OpcodeCodings143_18; - operand.values[36] = OpcodeCodings143_36; - asmError rv = ParseOperands(tokenBranches6345, operand); + operand.values[18] = OpcodeCodings145_18; + operand.values[36] = OpcodeCodings145_36; + asmError rv = ParseOperands(tokenBranches6351, operand); return rv; } -Coding x64Parser::OpcodeCodings144_18[] = { +Coding x64Parser::OpcodeCodings146_18[] = { { CODING_NAME("fimul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings144_36[] = { +Coding x64Parser::OpcodeCodings146_36[] = { { CODING_NAME("fimul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode144(x64Operand &operand) +asmError x64Parser::Opcode146(x64Operand &operand) { - operand.values[18] = OpcodeCodings144_18; - operand.values[36] = OpcodeCodings144_36; + operand.values[18] = OpcodeCodings146_18; + operand.values[36] = OpcodeCodings146_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings145_19[] = { +Coding x64Parser::OpcodeCodings147_19[] = { { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fincstp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 247, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode145(x64Operand &operand) +asmError x64Parser::Opcode147(x64Operand &operand) { - operand.values[19] = OpcodeCodings145_19; + operand.values[19] = OpcodeCodings147_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings146_19[] = { +Coding x64Parser::OpcodeCodings148_19[] = { { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("finit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode146(x64Operand &operand) +asmError x64Parser::Opcode148(x64Operand &operand) { - operand.values[19] = OpcodeCodings146_19; + operand.values[19] = OpcodeCodings148_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings147_19[] = { +Coding x64Parser::OpcodeCodings149_19[] = { { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fninit") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode147(x64Operand &operand) +asmError x64Parser::Opcode149(x64Operand &operand) { - operand.values[19] = OpcodeCodings147_19; + operand.values[19] = OpcodeCodings149_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings148_18[] = { +Coding x64Parser::OpcodeCodings150_18[] = { { CODING_NAME("fist") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings148_36[] = { +Coding x64Parser::OpcodeCodings150_36[] = { { CODING_NAME("fist") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode148(x64Operand &operand) +asmError x64Parser::Opcode150(x64Operand &operand) { - operand.values[18] = OpcodeCodings148_18; - operand.values[36] = OpcodeCodings148_36; + operand.values[18] = OpcodeCodings150_18; + operand.values[36] = OpcodeCodings150_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings149_18[] = { +Coding x64Parser::OpcodeCodings151_18[] = { { CODING_NAME("fistp") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings149_36[] = { +Coding x64Parser::OpcodeCodings151_36[] = { { CODING_NAME("fistp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode149(x64Operand &operand) +asmError x64Parser::Opcode151(x64Operand &operand) { - operand.values[18] = OpcodeCodings149_18; - operand.values[36] = OpcodeCodings149_36; - asmError rv = ParseOperands(tokenBranches6357, operand); + operand.values[18] = OpcodeCodings151_18; + operand.values[36] = OpcodeCodings151_36; + asmError rv = ParseOperands(tokenBranches6363, operand); return rv; } -Coding x64Parser::OpcodeCodings150_18[] = { +Coding x64Parser::OpcodeCodings152_18[] = { { CODING_NAME("fisub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings150_36[] = { +Coding x64Parser::OpcodeCodings152_36[] = { { CODING_NAME("fisub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode150(x64Operand &operand) +asmError x64Parser::Opcode152(x64Operand &operand) { - operand.values[18] = OpcodeCodings150_18; - operand.values[36] = OpcodeCodings150_36; + operand.values[18] = OpcodeCodings152_18; + operand.values[36] = OpcodeCodings152_36; asmError rv; { rv = Opcode10(operand); } return rv; } -Coding x64Parser::OpcodeCodings151_18[] = { +Coding x64Parser::OpcodeCodings153_18[] = { { CODING_NAME("fisubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings151_36[] = { +Coding x64Parser::OpcodeCodings153_36[] = { { CODING_NAME("fisubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode151(x64Operand &operand) +asmError x64Parser::Opcode153(x64Operand &operand) { - operand.values[18] = OpcodeCodings151_18; - operand.values[36] = OpcodeCodings151_36; + operand.values[18] = OpcodeCodings153_18; + operand.values[36] = OpcodeCodings153_36; asmError rv; { rv = Opcode10(operand); } return rv; } -asmError x64Parser::Opcode152(x64Operand &operand) +asmError x64Parser::Opcode154(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6364, operand); + asmError rv = ParseOperands(tokenBranches6370, operand); return rv; } -Coding x64Parser::OpcodeCodings153_19[] = { +Coding x64Parser::OpcodeCodings155_19[] = { { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fld1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode153(x64Operand &operand) +asmError x64Parser::Opcode155(x64Operand &operand) { - operand.values[19] = OpcodeCodings153_19; + operand.values[19] = OpcodeCodings155_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode154(x64Operand &operand) +asmError x64Parser::Opcode156(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6373, operand); + asmError rv = ParseOperands(tokenBranches6379, operand); return rv; } -asmError x64Parser::Opcode155(x64Operand &operand) +asmError x64Parser::Opcode157(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6376, operand); + asmError rv = ParseOperands(tokenBranches6382, operand); return rv; } -Coding x64Parser::OpcodeCodings156_19[] = { +Coding x64Parser::OpcodeCodings158_19[] = { { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldl2e") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode156(x64Operand &operand) +asmError x64Parser::Opcode158(x64Operand &operand) { - operand.values[19] = OpcodeCodings156_19; + operand.values[19] = OpcodeCodings158_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings157_19[] = { +Coding x64Parser::OpcodeCodings159_19[] = { { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldl2t") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode157(x64Operand &operand) +asmError x64Parser::Opcode159(x64Operand &operand) { - operand.values[19] = OpcodeCodings157_19; + operand.values[19] = OpcodeCodings159_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings158_19[] = { +Coding x64Parser::OpcodeCodings160_19[] = { { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldlg2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode158(x64Operand &operand) +asmError x64Parser::Opcode160(x64Operand &operand) { - operand.values[19] = OpcodeCodings158_19; + operand.values[19] = OpcodeCodings160_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings159_19[] = { +Coding x64Parser::OpcodeCodings161_19[] = { { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldln2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode159(x64Operand &operand) +asmError x64Parser::Opcode161(x64Operand &operand) { - operand.values[19] = OpcodeCodings159_19; + operand.values[19] = OpcodeCodings161_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings160_19[] = { +Coding x64Parser::OpcodeCodings162_19[] = { { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldpi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode160(x64Operand &operand) +asmError x64Parser::Opcode162(x64Operand &operand) { - operand.values[19] = OpcodeCodings160_19; + operand.values[19] = OpcodeCodings162_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings161_19[] = { +Coding x64Parser::OpcodeCodings163_19[] = { { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fldz") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode161(x64Operand &operand) +asmError x64Parser::Opcode163(x64Operand &operand) { - operand.values[19] = OpcodeCodings161_19; + operand.values[19] = OpcodeCodings163_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings162_18[] = { +Coding x64Parser::OpcodeCodings164_18[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings162_39[] = { +Coding x64Parser::OpcodeCodings164_39[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings162_36[] = { +Coding x64Parser::OpcodeCodings164_36[] = { { CODING_NAME("fmul") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode162(x64Operand &operand) +asmError x64Parser::Opcode164(x64Operand &operand) { - operand.values[18] = OpcodeCodings162_18; - operand.values[39] = OpcodeCodings162_39; - operand.values[36] = OpcodeCodings162_36; + operand.values[18] = OpcodeCodings164_18; + operand.values[39] = OpcodeCodings164_39; + operand.values[36] = OpcodeCodings164_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings163_18[] = { +Coding x64Parser::OpcodeCodings165_18[] = { { CODING_NAME("fmulp") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings163_19[] = { +Coding x64Parser::OpcodeCodings165_19[] = { { CODING_NAME("fmulp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode163(x64Operand &operand) +asmError x64Parser::Opcode165(x64Operand &operand) { - operand.values[18] = OpcodeCodings163_18; - operand.values[19] = OpcodeCodings163_19; + operand.values[18] = OpcodeCodings165_18; + operand.values[19] = OpcodeCodings165_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings164_19[] = { +Coding x64Parser::OpcodeCodings166_19[] = { { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fnop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode164(x64Operand &operand) +asmError x64Parser::Opcode166(x64Operand &operand) { - operand.values[19] = OpcodeCodings164_19; + operand.values[19] = OpcodeCodings166_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode165(x64Operand &operand) +asmError x64Parser::Opcode167(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6387, operand); + asmError rv = ParseOperands(tokenBranches6393, operand); return rv; } -Coding x64Parser::OpcodeCodings166_19[] = { +Coding x64Parser::OpcodeCodings168_19[] = { { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fpatan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode166(x64Operand &operand) +asmError x64Parser::Opcode168(x64Operand &operand) { - operand.values[19] = OpcodeCodings166_19; + operand.values[19] = OpcodeCodings168_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings167_19[] = { +Coding x64Parser::OpcodeCodings169_19[] = { { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fprem") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode167(x64Operand &operand) +asmError x64Parser::Opcode169(x64Operand &operand) { - operand.values[19] = OpcodeCodings167_19; + operand.values[19] = OpcodeCodings169_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings168_19[] = { +Coding x64Parser::OpcodeCodings170_19[] = { { CODING_NAME("fprem1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fprem1") (Coding::Type)(Coding::valSpecified), 245, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode168(x64Operand &operand) +asmError x64Parser::Opcode170(x64Operand &operand) { - operand.values[19] = OpcodeCodings168_19; + operand.values[19] = OpcodeCodings170_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings169_19[] = { +Coding x64Parser::OpcodeCodings171_19[] = { { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fptan") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode169(x64Operand &operand) +asmError x64Parser::Opcode171(x64Operand &operand) { - operand.values[19] = OpcodeCodings169_19; + operand.values[19] = OpcodeCodings171_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings170_19[] = { +Coding x64Parser::OpcodeCodings172_19[] = { { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("frndint") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode170(x64Operand &operand) +asmError x64Parser::Opcode172(x64Operand &operand) { - operand.values[19] = OpcodeCodings170_19; + operand.values[19] = OpcodeCodings172_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode171(x64Operand &operand) +asmError x64Parser::Opcode173(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6394, operand); + asmError rv = ParseOperands(tokenBranches6400, operand); return rv; } -asmError x64Parser::Opcode172(x64Operand &operand) +asmError x64Parser::Opcode174(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6396, operand); + asmError rv = ParseOperands(tokenBranches6402, operand); return rv; } -Coding x64Parser::OpcodeCodings173_19[] = { +Coding x64Parser::OpcodeCodings175_19[] = { { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fscale") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode173(x64Operand &operand) +asmError x64Parser::Opcode175(x64Operand &operand) { - operand.values[19] = OpcodeCodings173_19; + operand.values[19] = OpcodeCodings175_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings174_19[] = { +Coding x64Parser::OpcodeCodings176_19[] = { { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("fsetpm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode174(x64Operand &operand) +asmError x64Parser::Opcode176(x64Operand &operand) { - operand.values[19] = OpcodeCodings174_19; + operand.values[19] = OpcodeCodings176_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings175_19[] = { +Coding x64Parser::OpcodeCodings177_19[] = { { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsin") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode175(x64Operand &operand) +asmError x64Parser::Opcode177(x64Operand &operand) { - operand.values[19] = OpcodeCodings175_19; + operand.values[19] = OpcodeCodings177_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings176_19[] = { +Coding x64Parser::OpcodeCodings178_19[] = { { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsincos") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode176(x64Operand &operand) +asmError x64Parser::Opcode178(x64Operand &operand) { - operand.values[19] = OpcodeCodings176_19; + operand.values[19] = OpcodeCodings178_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings177_19[] = { +Coding x64Parser::OpcodeCodings179_19[] = { { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fsqrt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode177(x64Operand &operand) +asmError x64Parser::Opcode179(x64Operand &operand) { - operand.values[19] = OpcodeCodings177_19; + operand.values[19] = OpcodeCodings179_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode178(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6403, operand); - return rv; -} -asmError x64Parser::Opcode179(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6409, operand); - return rv; -} asmError x64Parser::Opcode180(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6412, operand); + asmError rv = ParseOperands(tokenBranches6409, operand); return rv; } asmError x64Parser::Opcode181(x64Operand &operand) @@ -40092,651 +40161,635 @@ asmError x64Parser::Opcode181(x64Operand &operand) } asmError x64Parser::Opcode182(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6417, operand); + asmError rv = ParseOperands(tokenBranches6418, operand); return rv; } asmError x64Parser::Opcode183(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6419, operand); + asmError rv = ParseOperands(tokenBranches6421, operand); return rv; } asmError x64Parser::Opcode184(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6427, operand); + asmError rv = ParseOperands(tokenBranches6423, operand); return rv; } asmError x64Parser::Opcode185(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6431, operand); + asmError rv = ParseOperands(tokenBranches6425, operand); + return rv; +} +asmError x64Parser::Opcode186(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6433, operand); return rv; } -Coding x64Parser::OpcodeCodings186_18[] = { +asmError x64Parser::Opcode187(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches6437, operand); + return rv; +} +Coding x64Parser::OpcodeCodings188_18[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings186_39[] = { +Coding x64Parser::OpcodeCodings188_39[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings186_36[] = { +Coding x64Parser::OpcodeCodings188_36[] = { { CODING_NAME("fsub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode186(x64Operand &operand) +asmError x64Parser::Opcode188(x64Operand &operand) { - operand.values[18] = OpcodeCodings186_18; - operand.values[39] = OpcodeCodings186_39; - operand.values[36] = OpcodeCodings186_36; + operand.values[18] = OpcodeCodings188_18; + operand.values[39] = OpcodeCodings188_39; + operand.values[36] = OpcodeCodings188_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings187_18[] = { +Coding x64Parser::OpcodeCodings189_18[] = { { CODING_NAME("fsubp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings187_19[] = { +Coding x64Parser::OpcodeCodings189_19[] = { { CODING_NAME("fsubp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode187(x64Operand &operand) +asmError x64Parser::Opcode189(x64Operand &operand) { - operand.values[18] = OpcodeCodings187_18; - operand.values[19] = OpcodeCodings187_19; + operand.values[18] = OpcodeCodings189_18; + operand.values[19] = OpcodeCodings189_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings188_18[] = { +Coding x64Parser::OpcodeCodings190_18[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings188_39[] = { +Coding x64Parser::OpcodeCodings190_39[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings188_36[] = { +Coding x64Parser::OpcodeCodings190_36[] = { { CODING_NAME("fsubr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode188(x64Operand &operand) +asmError x64Parser::Opcode190(x64Operand &operand) { - operand.values[18] = OpcodeCodings188_18; - operand.values[39] = OpcodeCodings188_39; - operand.values[36] = OpcodeCodings188_36; + operand.values[18] = OpcodeCodings190_18; + operand.values[39] = OpcodeCodings190_39; + operand.values[36] = OpcodeCodings190_36; asmError rv; { rv = Opcode8(operand); } return rv; } -Coding x64Parser::OpcodeCodings189_18[] = { +Coding x64Parser::OpcodeCodings191_18[] = { { CODING_NAME("fsubrp") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings189_19[] = { +Coding x64Parser::OpcodeCodings191_19[] = { { CODING_NAME("fsubrp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode189(x64Operand &operand) +asmError x64Parser::Opcode191(x64Operand &operand) { - operand.values[18] = OpcodeCodings189_18; - operand.values[19] = OpcodeCodings189_19; + operand.values[18] = OpcodeCodings191_18; + operand.values[19] = OpcodeCodings191_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings190_19[] = { +Coding x64Parser::OpcodeCodings192_19[] = { { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("ftst") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode190(x64Operand &operand) +asmError x64Parser::Opcode192(x64Operand &operand) { - operand.values[19] = OpcodeCodings190_19; + operand.values[19] = OpcodeCodings192_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings191_18[] = { +Coding x64Parser::OpcodeCodings193_18[] = { { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings191_19[] = { +Coding x64Parser::OpcodeCodings193_19[] = { { CODING_NAME("fucom") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode191(x64Operand &operand) +asmError x64Parser::Opcode193(x64Operand &operand) { - operand.values[18] = OpcodeCodings191_18; - operand.values[19] = OpcodeCodings191_19; + operand.values[18] = OpcodeCodings193_18; + operand.values[19] = OpcodeCodings193_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings192_18[] = { +Coding x64Parser::OpcodeCodings194_18[] = { { CODING_NAME("fucomi") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings192_36[] = { +Coding x64Parser::OpcodeCodings194_36[] = { { CODING_NAME("fucomi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode192(x64Operand &operand) +asmError x64Parser::Opcode194(x64Operand &operand) { - operand.values[18] = OpcodeCodings192_18; - operand.values[36] = OpcodeCodings192_36; - asmError rv = ParseOperands(tokenBranches6441, operand); + operand.values[18] = OpcodeCodings194_18; + operand.values[36] = OpcodeCodings194_36; + asmError rv = ParseOperands(tokenBranches6447, operand); return rv; } -Coding x64Parser::OpcodeCodings193_18[] = { +Coding x64Parser::OpcodeCodings195_18[] = { { CODING_NAME("fucomip") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings193_36[] = { +Coding x64Parser::OpcodeCodings195_36[] = { { CODING_NAME("fucomip") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode193(x64Operand &operand) +asmError x64Parser::Opcode195(x64Operand &operand) { - operand.values[18] = OpcodeCodings193_18; - operand.values[36] = OpcodeCodings193_36; - asmError rv = ParseOperands(tokenBranches6445, operand); + operand.values[18] = OpcodeCodings195_18; + operand.values[36] = OpcodeCodings195_36; + asmError rv = ParseOperands(tokenBranches6451, operand); return rv; } -Coding x64Parser::OpcodeCodings194_18[] = { +Coding x64Parser::OpcodeCodings196_18[] = { { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings194_19[] = { +Coding x64Parser::OpcodeCodings196_19[] = { { CODING_NAME("fucomp") (Coding::Type)(Coding::valSpecified), 221, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode194(x64Operand &operand) +asmError x64Parser::Opcode196(x64Operand &operand) { - operand.values[18] = OpcodeCodings194_18; - operand.values[19] = OpcodeCodings194_19; + operand.values[18] = OpcodeCodings196_18; + operand.values[19] = OpcodeCodings196_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings195_19[] = { +Coding x64Parser::OpcodeCodings197_19[] = { { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("fucompp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode195(x64Operand &operand) +asmError x64Parser::Opcode197(x64Operand &operand) { - operand.values[19] = OpcodeCodings195_19; + operand.values[19] = OpcodeCodings197_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings196_19[] = { +Coding x64Parser::OpcodeCodings198_19[] = { { CODING_NAME("fwait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode196(x64Operand &operand) +asmError x64Parser::Opcode198(x64Operand &operand) { - operand.values[19] = OpcodeCodings196_19; + operand.values[19] = OpcodeCodings198_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings197_19[] = { +Coding x64Parser::OpcodeCodings199_19[] = { { CODING_NAME("fxam") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fxam") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode197(x64Operand &operand) +asmError x64Parser::Opcode199(x64Operand &operand) { - operand.values[19] = OpcodeCodings197_19; + operand.values[19] = OpcodeCodings199_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings198_18[] = { +Coding x64Parser::OpcodeCodings200_18[] = { { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings198_19[] = { +Coding x64Parser::OpcodeCodings200_19[] = { { CODING_NAME("fxch") (Coding::Type)(Coding::valSpecified), 217, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode198(x64Operand &operand) +asmError x64Parser::Opcode200(x64Operand &operand) { - operand.values[18] = OpcodeCodings198_18; - operand.values[19] = OpcodeCodings198_19; + operand.values[18] = OpcodeCodings200_18; + operand.values[19] = OpcodeCodings200_19; asmError rv; { rv = Opcode9(operand); } return rv; } -Coding x64Parser::OpcodeCodings199_18[] = { +Coding x64Parser::OpcodeCodings201_18[] = { { CODING_NAME("fxch4") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings199_36[] = { +Coding x64Parser::OpcodeCodings201_36[] = { { CODING_NAME("fxch4") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode199(x64Operand &operand) +asmError x64Parser::Opcode201(x64Operand &operand) { - operand.values[18] = OpcodeCodings199_18; - operand.values[36] = OpcodeCodings199_36; - asmError rv = ParseOperands(tokenBranches6454, operand); + operand.values[18] = OpcodeCodings201_18; + operand.values[36] = OpcodeCodings201_36; + asmError rv = ParseOperands(tokenBranches6460, operand); return rv; } -Coding x64Parser::OpcodeCodings200_18[] = { +Coding x64Parser::OpcodeCodings202_18[] = { { CODING_NAME("fxch7") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings200_36[] = { +Coding x64Parser::OpcodeCodings202_36[] = { { CODING_NAME("fxch7") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode200(x64Operand &operand) +asmError x64Parser::Opcode202(x64Operand &operand) { - operand.values[18] = OpcodeCodings200_18; - operand.values[36] = OpcodeCodings200_36; - asmError rv = ParseOperands(tokenBranches6458, operand); + operand.values[18] = OpcodeCodings202_18; + operand.values[36] = OpcodeCodings202_36; + asmError rv = ParseOperands(tokenBranches6464, operand); return rv; } -asmError x64Parser::Opcode201(x64Operand &operand) +asmError x64Parser::Opcode203(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6462, operand); + asmError rv = ParseOperands(tokenBranches6468, operand); return rv; } -asmError x64Parser::Opcode202(x64Operand &operand) +asmError x64Parser::Opcode204(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6464, operand); + asmError rv = ParseOperands(tokenBranches6470, operand); return rv; } -Coding x64Parser::OpcodeCodings203_19[] = { +Coding x64Parser::OpcodeCodings205_19[] = { { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fxtract") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode203(x64Operand &operand) +asmError x64Parser::Opcode205(x64Operand &operand) { - operand.values[19] = OpcodeCodings203_19; + operand.values[19] = OpcodeCodings205_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings204_19[] = { +Coding x64Parser::OpcodeCodings206_19[] = { { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fyl2x") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode204(x64Operand &operand) +asmError x64Parser::Opcode206(x64Operand &operand) { - operand.values[19] = OpcodeCodings204_19; + operand.values[19] = OpcodeCodings206_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings205_19[] = { +Coding x64Parser::OpcodeCodings207_19[] = { { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("fyl2xp1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode205(x64Operand &operand) +asmError x64Parser::Opcode207(x64Operand &operand) { - operand.values[19] = OpcodeCodings205_19; + operand.values[19] = OpcodeCodings207_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings206_19[] = { +Coding x64Parser::OpcodeCodings208_19[] = { { CODING_NAME("hlt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode206(x64Operand &operand) +asmError x64Parser::Opcode208(x64Operand &operand) { - operand.values[19] = OpcodeCodings206_19; + operand.values[19] = OpcodeCodings208_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings207_19[] = { +Coding x64Parser::OpcodeCodings209_19[] = { { CODING_NAME("icebp") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode207(x64Operand &operand) +asmError x64Parser::Opcode209(x64Operand &operand) { - operand.values[19] = OpcodeCodings207_19; + operand.values[19] = OpcodeCodings209_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings208_18[] = { +Coding x64Parser::OpcodeCodings210_18[] = { { CODING_NAME("idiv") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode208(x64Operand &operand) +asmError x64Parser::Opcode210(x64Operand &operand) { - operand.values[18] = OpcodeCodings208_18; + operand.values[18] = OpcodeCodings210_18; asmError rv; { rv = Opcode7(operand); } return rv; } -asmError x64Parser::Opcode209(x64Operand &operand) +asmError x64Parser::Opcode211(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6472, operand); + asmError rv = ParseOperands(tokenBranches6478, operand); return rv; } -asmError x64Parser::Opcode210(x64Operand &operand) +asmError x64Parser::Opcode212(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6556, operand); + asmError rv = ParseOperands(tokenBranches6562, operand); return rv; } -asmError x64Parser::Opcode211(x64Operand &operand) +asmError x64Parser::Opcode213(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6585, operand); + asmError rv = ParseOperands(tokenBranches6591, operand); return rv; } -Coding x64Parser::OpcodeCodings212_19[] = { +Coding x64Parser::OpcodeCodings214_19[] = { { CODING_NAME("insb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode212(x64Operand &operand) +asmError x64Parser::Opcode214(x64Operand &operand) { - operand.values[19] = OpcodeCodings212_19; + operand.values[19] = OpcodeCodings214_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings213_19[] = { +Coding x64Parser::OpcodeCodings215_19[] = { { CODING_NAME("insw") Coding::stateFunc, 4 }, { CODING_NAME("insw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode213(x64Operand &operand) +asmError x64Parser::Opcode215(x64Operand &operand) { - operand.values[19] = OpcodeCodings213_19; + operand.values[19] = OpcodeCodings215_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings214_19[] = { +Coding x64Parser::OpcodeCodings216_19[] = { { CODING_NAME("insd") Coding::stateFunc, 5 }, { CODING_NAME("insd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode214(x64Operand &operand) +asmError x64Parser::Opcode216(x64Operand &operand) { - operand.values[19] = OpcodeCodings214_19; + operand.values[19] = OpcodeCodings216_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings215_18[] = { +Coding x64Parser::OpcodeCodings217_18[] = { { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings215_19[] = { +Coding x64Parser::OpcodeCodings217_19[] = { { CODING_NAME("inc") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode215(x64Operand &operand) +asmError x64Parser::Opcode217(x64Operand &operand) { - operand.values[18] = OpcodeCodings215_18; - operand.values[19] = OpcodeCodings215_19; + operand.values[18] = OpcodeCodings217_18; + operand.values[19] = OpcodeCodings217_19; asmError rv; { rv = Opcode6(operand); } return rv; } -asmError x64Parser::Opcode216(x64Operand &operand) +asmError x64Parser::Opcode218(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6728, operand); + asmError rv = ParseOperands(tokenBranches6734, operand); return rv; } -Coding x64Parser::OpcodeCodings217_19[] = { +Coding x64Parser::OpcodeCodings219_19[] = { { CODING_NAME("int1") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 241, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode217(x64Operand &operand) +asmError x64Parser::Opcode219(x64Operand &operand) { - operand.values[19] = OpcodeCodings217_19; + operand.values[19] = OpcodeCodings219_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings218_19[] = { +Coding x64Parser::OpcodeCodings220_19[] = { { CODING_NAME("int3") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 204, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode218(x64Operand &operand) +asmError x64Parser::Opcode220(x64Operand &operand) { - operand.values[19] = OpcodeCodings218_19; + operand.values[19] = OpcodeCodings220_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings219_19[] = { +Coding x64Parser::OpcodeCodings221_19[] = { { CODING_NAME("into") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 206, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode219(x64Operand &operand) +asmError x64Parser::Opcode221(x64Operand &operand) { - operand.values[19] = OpcodeCodings219_19; + operand.values[19] = OpcodeCodings221_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings220_19[] = { +Coding x64Parser::OpcodeCodings222_19[] = { { CODING_NAME("invd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode220(x64Operand &operand) +asmError x64Parser::Opcode222(x64Operand &operand) { - operand.values[19] = OpcodeCodings220_19; + operand.values[19] = OpcodeCodings222_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode221(x64Operand &operand) +asmError x64Parser::Opcode223(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6735, operand); + asmError rv = ParseOperands(tokenBranches6741, operand); return rv; } -Coding x64Parser::OpcodeCodings222_19[] = { +Coding x64Parser::OpcodeCodings224_19[] = { { CODING_NAME("iret") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode222(x64Operand &operand) +asmError x64Parser::Opcode224(x64Operand &operand) { - operand.values[19] = OpcodeCodings222_19; + operand.values[19] = OpcodeCodings224_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings223_19[] = { +Coding x64Parser::OpcodeCodings225_19[] = { { CODING_NAME("iretw") Coding::stateFunc, 4 }, { CODING_NAME("iretw") (Coding::Type)(Coding::valSpecified), 207, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode223(x64Operand &operand) +asmError x64Parser::Opcode225(x64Operand &operand) { - operand.values[19] = OpcodeCodings223_19; + operand.values[19] = OpcodeCodings225_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode224(x64Operand &operand) +asmError x64Parser::Opcode226(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6739, operand); + asmError rv = ParseOperands(tokenBranches6745, operand); return rv; } -Coding x64Parser::OpcodeCodings225_19[] = { +Coding x64Parser::OpcodeCodings227_19[] = { { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("iretq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode225(x64Operand &operand) +asmError x64Parser::Opcode227(x64Operand &operand) { - operand.values[19] = OpcodeCodings225_19; + operand.values[19] = OpcodeCodings227_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings226_38[] = { +Coding x64Parser::OpcodeCodings228_38[] = { { CODING_NAME("ja") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode226(x64Operand &operand) +asmError x64Parser::Opcode228(x64Operand &operand) { - operand.values[38] = OpcodeCodings226_38; + operand.values[38] = OpcodeCodings228_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings227_38[] = { +Coding x64Parser::OpcodeCodings229_38[] = { { CODING_NAME("jae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode227(x64Operand &operand) +asmError x64Parser::Opcode229(x64Operand &operand) { - operand.values[38] = OpcodeCodings227_38; + operand.values[38] = OpcodeCodings229_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings228_38[] = { +Coding x64Parser::OpcodeCodings230_38[] = { { CODING_NAME("jb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode228(x64Operand &operand) +asmError x64Parser::Opcode230(x64Operand &operand) { - operand.values[38] = OpcodeCodings228_38; + operand.values[38] = OpcodeCodings230_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings229_38[] = { +Coding x64Parser::OpcodeCodings231_38[] = { { CODING_NAME("jbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode229(x64Operand &operand) +asmError x64Parser::Opcode231(x64Operand &operand) { - operand.values[38] = OpcodeCodings229_38; + operand.values[38] = OpcodeCodings231_38; asmError rv; { rv = Opcode12(operand); } return rv; } -Coding x64Parser::OpcodeCodings230_38[] = { +Coding x64Parser::OpcodeCodings232_38[] = { { CODING_NAME("jc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode230(x64Operand &operand) +asmError x64Parser::Opcode232(x64Operand &operand) { - operand.values[38] = OpcodeCodings230_38; + operand.values[38] = OpcodeCodings232_38; asmError rv; { rv = Opcode12(operand); } return rv; } -asmError x64Parser::Opcode231(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6747, operand); - return rv; -} -asmError x64Parser::Opcode232(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches6749, operand); - return rv; -} -Coding x64Parser::OpcodeCodings233_38[] = { - { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode233(x64Operand &operand) { - operand.values[38] = OpcodeCodings233_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6753, operand); return rv; } -Coding x64Parser::OpcodeCodings234_38[] = { - { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode234(x64Operand &operand) { - operand.values[38] = OpcodeCodings234_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6755, operand); return rv; } Coding x64Parser::OpcodeCodings235_38[] = { - { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("je") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode235(x64Operand &operand) @@ -40749,7 +40802,7 @@ asmError x64Parser::Opcode235(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings236_38[] = { - { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("jg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode236(x64Operand &operand) @@ -40762,7 +40815,7 @@ asmError x64Parser::Opcode236(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings237_38[] = { - { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("jge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode237(x64Operand &operand) @@ -40774,13 +40827,21 @@ asmError x64Parser::Opcode237(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings238_38[] = { + { CODING_NAME("jl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode238(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6756, operand); + operand.values[38] = OpcodeCodings238_38; + asmError rv; + { + rv = Opcode12(operand); + } return rv; } Coding x64Parser::OpcodeCodings239_38[] = { - { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("jle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode239(x64Operand &operand) @@ -40792,21 +40853,13 @@ asmError x64Parser::Opcode239(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings240_38[] = { - { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode240(x64Operand &operand) { - operand.values[38] = OpcodeCodings240_38; - asmError rv; - { - rv = Opcode12(operand); - } + asmError rv = ParseOperands(tokenBranches6762, operand); return rv; } Coding x64Parser::OpcodeCodings241_38[] = { - { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("jna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode241(x64Operand &operand) @@ -40819,7 +40872,7 @@ asmError x64Parser::Opcode241(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings242_38[] = { - { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("jnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode242(x64Operand &operand) @@ -40832,7 +40885,7 @@ asmError x64Parser::Opcode242(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings243_38[] = { - { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("jnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode243(x64Operand &operand) @@ -40845,7 +40898,7 @@ asmError x64Parser::Opcode243(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings244_38[] = { - { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("jnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode244(x64Operand &operand) @@ -40858,7 +40911,7 @@ asmError x64Parser::Opcode244(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings245_38[] = { - { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("jnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode245(x64Operand &operand) @@ -40871,7 +40924,7 @@ asmError x64Parser::Opcode245(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings246_38[] = { - { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("jne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode246(x64Operand &operand) @@ -40884,7 +40937,7 @@ asmError x64Parser::Opcode246(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings247_38[] = { - { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("jng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode247(x64Operand &operand) @@ -40897,7 +40950,7 @@ asmError x64Parser::Opcode247(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings248_38[] = { - { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("jnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode248(x64Operand &operand) @@ -40910,7 +40963,7 @@ asmError x64Parser::Opcode248(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings249_38[] = { - { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("jnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode249(x64Operand &operand) @@ -40923,7 +40976,7 @@ asmError x64Parser::Opcode249(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings250_38[] = { - { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("jnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode250(x64Operand &operand) @@ -40936,7 +40989,7 @@ asmError x64Parser::Opcode250(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings251_38[] = { - { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("jno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode251(x64Operand &operand) @@ -40949,7 +41002,7 @@ asmError x64Parser::Opcode251(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings252_38[] = { - { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("jnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode252(x64Operand &operand) @@ -40962,7 +41015,7 @@ asmError x64Parser::Opcode252(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings253_38[] = { - { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("jns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode253(x64Operand &operand) @@ -40975,7 +41028,7 @@ asmError x64Parser::Opcode253(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings254_38[] = { - { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("jnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode254(x64Operand &operand) @@ -40988,7 +41041,7 @@ asmError x64Parser::Opcode254(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings255_38[] = { - { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("jo") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode255(x64Operand &operand) @@ -41001,7 +41054,7 @@ asmError x64Parser::Opcode255(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings256_38[] = { - { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("jp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode256(x64Operand &operand) @@ -41014,7 +41067,7 @@ asmError x64Parser::Opcode256(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings257_38[] = { - { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("jpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode257(x64Operand &operand) @@ -41027,7 +41080,7 @@ asmError x64Parser::Opcode257(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings258_38[] = { - { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("jpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode258(x64Operand &operand) @@ -41039,1044 +41092,1044 @@ asmError x64Parser::Opcode258(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings259_19[] = { - { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings259_38[] = { + { CODING_NAME("js") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode259(x64Operand &operand) { - operand.values[19] = OpcodeCodings259_19; + operand.values[38] = OpcodeCodings259_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings260_38[] = { + { CODING_NAME("jz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode260(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings260_38; + asmError rv; + { + rv = Opcode12(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings261_19[] = { + { CODING_NAME("lahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 159, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode261(x64Operand &operand) +{ + operand.values[19] = OpcodeCodings261_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings260_36[] = { +Coding x64Parser::OpcodeCodings262_36[] = { { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lar") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 2, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode260(x64Operand &operand) +asmError x64Parser::Opcode262(x64Operand &operand) { - operand.values[36] = OpcodeCodings260_36; + operand.values[36] = OpcodeCodings262_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings261_36[] = { +Coding x64Parser::OpcodeCodings263_36[] = { { CODING_NAME("lds") Coding::stateFunc, 7 }, { CODING_NAME("lds") (Coding::Type)(Coding::valSpecified), 197, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode261(x64Operand &operand) +asmError x64Parser::Opcode263(x64Operand &operand) { - operand.values[36] = OpcodeCodings261_36; + operand.values[36] = OpcodeCodings263_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings262_36[] = { +Coding x64Parser::OpcodeCodings264_36[] = { { CODING_NAME("lea") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 141, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode262(x64Operand &operand) +asmError x64Parser::Opcode264(x64Operand &operand) { - operand.values[36] = OpcodeCodings262_36; + operand.values[36] = OpcodeCodings264_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings263_19[] = { +Coding x64Parser::OpcodeCodings265_19[] = { { CODING_NAME("leave") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 201, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode263(x64Operand &operand) +asmError x64Parser::Opcode265(x64Operand &operand) { - operand.values[19] = OpcodeCodings263_19; + operand.values[19] = OpcodeCodings265_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings264_36[] = { +Coding x64Parser::OpcodeCodings266_36[] = { { CODING_NAME("les") Coding::stateFunc, 7 }, { CODING_NAME("les") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 196, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode264(x64Operand &operand) +asmError x64Parser::Opcode266(x64Operand &operand) { - operand.values[36] = OpcodeCodings264_36; + operand.values[36] = OpcodeCodings266_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings265_19[] = { +Coding x64Parser::OpcodeCodings267_19[] = { { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("lfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode265(x64Operand &operand) +asmError x64Parser::Opcode267(x64Operand &operand) { - operand.values[19] = OpcodeCodings265_19; + operand.values[19] = OpcodeCodings267_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings266_36[] = { +Coding x64Parser::OpcodeCodings268_36[] = { { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lfs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 180, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode266(x64Operand &operand) +asmError x64Parser::Opcode268(x64Operand &operand) { - operand.values[36] = OpcodeCodings266_36; + operand.values[36] = OpcodeCodings268_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings267_18[] = { +Coding x64Parser::OpcodeCodings269_18[] = { { CODING_NAME("lgdt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings267_19[] = { +Coding x64Parser::OpcodeCodings269_19[] = { { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode267(x64Operand &operand) +asmError x64Parser::Opcode269(x64Operand &operand) { - operand.values[18] = OpcodeCodings267_18; - operand.values[19] = OpcodeCodings267_19; + operand.values[18] = OpcodeCodings269_18; + operand.values[19] = OpcodeCodings269_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings268_36[] = { +Coding x64Parser::OpcodeCodings270_36[] = { { CODING_NAME("lgs") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lgs") (Coding::Type)(Coding::valSpecified), 181, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode268(x64Operand &operand) +asmError x64Parser::Opcode270(x64Operand &operand) { - operand.values[36] = OpcodeCodings268_36; + operand.values[36] = OpcodeCodings270_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings269_18[] = { +Coding x64Parser::OpcodeCodings271_18[] = { { CODING_NAME("lidt") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings269_19[] = { +Coding x64Parser::OpcodeCodings271_19[] = { { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode269(x64Operand &operand) +asmError x64Parser::Opcode271(x64Operand &operand) { - operand.values[18] = OpcodeCodings269_18; - operand.values[19] = OpcodeCodings269_19; + operand.values[18] = OpcodeCodings271_18; + operand.values[19] = OpcodeCodings271_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings270_18[] = { +Coding x64Parser::OpcodeCodings272_18[] = { { CODING_NAME("lldt") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings270_19[] = { +Coding x64Parser::OpcodeCodings272_19[] = { { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode270(x64Operand &operand) +asmError x64Parser::Opcode272(x64Operand &operand) { - operand.values[18] = OpcodeCodings270_18; - operand.values[19] = OpcodeCodings270_19; + operand.values[18] = OpcodeCodings272_18; + operand.values[19] = OpcodeCodings272_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings271_18[] = { +Coding x64Parser::OpcodeCodings273_18[] = { { CODING_NAME("lmsw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings271_19[] = { +Coding x64Parser::OpcodeCodings273_19[] = { { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lmsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode271(x64Operand &operand) +asmError x64Parser::Opcode273(x64Operand &operand) { - operand.values[18] = OpcodeCodings271_18; - operand.values[19] = OpcodeCodings271_19; - asmError rv = ParseOperands(tokenBranches6829, operand); + operand.values[18] = OpcodeCodings273_18; + operand.values[19] = OpcodeCodings273_19; + asmError rv = ParseOperands(tokenBranches6835, operand); return rv; } -asmError x64Parser::Opcode272(x64Operand &operand) +asmError x64Parser::Opcode274(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6831, operand); + asmError rv = ParseOperands(tokenBranches6837, operand); return rv; } -Coding x64Parser::OpcodeCodings273_19[] = { +Coding x64Parser::OpcodeCodings275_19[] = { { CODING_NAME("lodsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode273(x64Operand &operand) +asmError x64Parser::Opcode275(x64Operand &operand) { - operand.values[19] = OpcodeCodings273_19; + operand.values[19] = OpcodeCodings275_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings274_19[] = { +Coding x64Parser::OpcodeCodings276_19[] = { { CODING_NAME("lodsw") Coding::stateFunc, 4 }, { CODING_NAME("lodsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode274(x64Operand &operand) +asmError x64Parser::Opcode276(x64Operand &operand) { - operand.values[19] = OpcodeCodings274_19; + operand.values[19] = OpcodeCodings276_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings275_19[] = { +Coding x64Parser::OpcodeCodings277_19[] = { { CODING_NAME("lodsd") Coding::stateFunc, 5 }, { CODING_NAME("lodsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode275(x64Operand &operand) +asmError x64Parser::Opcode277(x64Operand &operand) { - operand.values[19] = OpcodeCodings275_19; + operand.values[19] = OpcodeCodings277_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode276(x64Operand &operand) +asmError x64Parser::Opcode278(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6959, operand); + asmError rv = ParseOperands(tokenBranches6965, operand); return rv; } -asmError x64Parser::Opcode277(x64Operand &operand) +asmError x64Parser::Opcode279(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6961, operand); + asmError rv = ParseOperands(tokenBranches6967, operand); return rv; } -asmError x64Parser::Opcode278(x64Operand &operand) +asmError x64Parser::Opcode280(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6963, operand); + asmError rv = ParseOperands(tokenBranches6969, operand); return rv; } -asmError x64Parser::Opcode279(x64Operand &operand) +asmError x64Parser::Opcode281(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6965, operand); + asmError rv = ParseOperands(tokenBranches6971, operand); return rv; } -asmError x64Parser::Opcode280(x64Operand &operand) +asmError x64Parser::Opcode282(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6967, operand); + asmError rv = ParseOperands(tokenBranches6973, operand); return rv; } -asmError x64Parser::Opcode281(x64Operand &operand) +asmError x64Parser::Opcode283(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6969, operand); + asmError rv = ParseOperands(tokenBranches6975, operand); return rv; } -Coding x64Parser::OpcodeCodings282_36[] = { +Coding x64Parser::OpcodeCodings284_36[] = { { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lsl") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 3, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode282(x64Operand &operand) +asmError x64Parser::Opcode284(x64Operand &operand) { - operand.values[36] = OpcodeCodings282_36; + operand.values[36] = OpcodeCodings284_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings283_36[] = { +Coding x64Parser::OpcodeCodings285_36[] = { { CODING_NAME("lss") Coding::stateFunc, 7 }, { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("lss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 178, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode283(x64Operand &operand) +asmError x64Parser::Opcode285(x64Operand &operand) { - operand.values[36] = OpcodeCodings283_36; + operand.values[36] = OpcodeCodings285_36; asmError rv; { rv = Opcode3(operand); } return rv; } -Coding x64Parser::OpcodeCodings284_18[] = { +Coding x64Parser::OpcodeCodings286_18[] = { { CODING_NAME("ltr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings284_19[] = { +Coding x64Parser::OpcodeCodings286_19[] = { { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("ltr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode284(x64Operand &operand) +asmError x64Parser::Opcode286(x64Operand &operand) { - operand.values[18] = OpcodeCodings284_18; - operand.values[19] = OpcodeCodings284_19; - asmError rv = ParseOperands(tokenBranches6973, operand); + operand.values[18] = OpcodeCodings286_18; + operand.values[19] = OpcodeCodings286_19; + asmError rv = ParseOperands(tokenBranches6979, operand); if (rv == AERR_NONE) { rv = Opcode18(operand); } return rv; } -asmError x64Parser::Opcode285(x64Operand &operand) +asmError x64Parser::Opcode287(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches6975, operand); + asmError rv = ParseOperands(tokenBranches6981, operand); return rv; } -asmError x64Parser::Opcode286(x64Operand &operand) +asmError x64Parser::Opcode288(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7284, operand); + asmError rv = ParseOperands(tokenBranches7290, operand); return rv; } -Coding x64Parser::OpcodeCodings287_36[] = { +Coding x64Parser::OpcodeCodings289_36[] = { { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, { CODING_NAME("movbe") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode287(x64Operand &operand) +asmError x64Parser::Opcode289(x64Operand &operand) { - operand.values[36] = OpcodeCodings287_36; - asmError rv = ParseOperands(tokenBranches7547, operand); + operand.values[36] = OpcodeCodings289_36; + asmError rv = ParseOperands(tokenBranches7553, operand); return rv; } -Coding x64Parser::OpcodeCodings288_19[] = { +Coding x64Parser::OpcodeCodings290_19[] = { { CODING_NAME("movsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode288(x64Operand &operand) +asmError x64Parser::Opcode290(x64Operand &operand) { - operand.values[19] = OpcodeCodings288_19; + operand.values[19] = OpcodeCodings290_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings289_19[] = { +Coding x64Parser::OpcodeCodings291_19[] = { { CODING_NAME("movsw") Coding::stateFunc, 4 }, { CODING_NAME("movsw") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode289(x64Operand &operand) +asmError x64Parser::Opcode291(x64Operand &operand) { - operand.values[19] = OpcodeCodings289_19; + operand.values[19] = OpcodeCodings291_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode290(x64Operand &operand) +asmError x64Parser::Opcode292(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7574, operand); + asmError rv = ParseOperands(tokenBranches7580, operand); return rv; } -asmError x64Parser::Opcode291(x64Operand &operand) +asmError x64Parser::Opcode293(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7582, operand); + asmError rv = ParseOperands(tokenBranches7588, operand); return rv; } -Coding x64Parser::OpcodeCodings292_36[] = { +Coding x64Parser::OpcodeCodings294_36[] = { { CODING_NAME("movsx") (Coding::Type)(Coding::valSpecified), 190, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode292(x64Operand &operand) +asmError x64Parser::Opcode294(x64Operand &operand) { - operand.values[36] = OpcodeCodings292_36; + operand.values[36] = OpcodeCodings294_36; asmError rv; { rv = Opcode15(operand); } return rv; } -Coding x64Parser::OpcodeCodings293_36[] = { +Coding x64Parser::OpcodeCodings295_36[] = { { CODING_NAME("movzx") (Coding::Type)(Coding::valSpecified), 182, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode293(x64Operand &operand) +asmError x64Parser::Opcode295(x64Operand &operand) { - operand.values[36] = OpcodeCodings293_36; + operand.values[36] = OpcodeCodings295_36; asmError rv; { rv = Opcode15(operand); } return rv; } -asmError x64Parser::Opcode294(x64Operand &operand) +asmError x64Parser::Opcode296(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7586, operand); + asmError rv = ParseOperands(tokenBranches7592, operand); return rv; } -Coding x64Parser::OpcodeCodings295_18[] = { +Coding x64Parser::OpcodeCodings297_18[] = { { CODING_NAME("mul") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode295(x64Operand &operand) +asmError x64Parser::Opcode297(x64Operand &operand) { - operand.values[18] = OpcodeCodings295_18; + operand.values[18] = OpcodeCodings297_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings296_18[] = { +Coding x64Parser::OpcodeCodings298_18[] = { { CODING_NAME("neg") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode296(x64Operand &operand) +asmError x64Parser::Opcode298(x64Operand &operand) { - operand.values[18] = OpcodeCodings296_18; + operand.values[18] = OpcodeCodings298_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings297_19[] = { +Coding x64Parser::OpcodeCodings299_19[] = { { CODING_NAME("nop") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode297(x64Operand &operand) +asmError x64Parser::Opcode299(x64Operand &operand) { - operand.values[19] = OpcodeCodings297_19; + operand.values[19] = OpcodeCodings299_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings298_18[] = { +Coding x64Parser::OpcodeCodings300_18[] = { { CODING_NAME("not") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode298(x64Operand &operand) +asmError x64Parser::Opcode300(x64Operand &operand) { - operand.values[18] = OpcodeCodings298_18; + operand.values[18] = OpcodeCodings300_18; asmError rv; { rv = Opcode7(operand); } return rv; } -Coding x64Parser::OpcodeCodings299_18[] = { +Coding x64Parser::OpcodeCodings301_18[] = { { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings299_36[] = { +Coding x64Parser::OpcodeCodings301_36[] = { { CODING_NAME("or") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings299_37[] = { +Coding x64Parser::OpcodeCodings301_37[] = { { CODING_NAME("or") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode299(x64Operand &operand) +asmError x64Parser::Opcode301(x64Operand &operand) { - operand.values[18] = OpcodeCodings299_18; - operand.values[36] = OpcodeCodings299_36; - operand.values[37] = OpcodeCodings299_37; + operand.values[18] = OpcodeCodings301_18; + operand.values[36] = OpcodeCodings301_36; + operand.values[37] = OpcodeCodings301_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode300(x64Operand &operand) +asmError x64Parser::Opcode302(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7606, operand); + asmError rv = ParseOperands(tokenBranches7612, operand); return rv; } -asmError x64Parser::Opcode301(x64Operand &operand) +asmError x64Parser::Opcode303(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7635, operand); + asmError rv = ParseOperands(tokenBranches7641, operand); return rv; } -Coding x64Parser::OpcodeCodings302_19[] = { +Coding x64Parser::OpcodeCodings304_19[] = { { CODING_NAME("outsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode302(x64Operand &operand) +asmError x64Parser::Opcode304(x64Operand &operand) { - operand.values[19] = OpcodeCodings302_19; + operand.values[19] = OpcodeCodings304_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings303_19[] = { +Coding x64Parser::OpcodeCodings305_19[] = { { CODING_NAME("outsw") Coding::stateFunc, 4 }, { CODING_NAME("outsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode303(x64Operand &operand) +asmError x64Parser::Opcode305(x64Operand &operand) { - operand.values[19] = OpcodeCodings303_19; + operand.values[19] = OpcodeCodings305_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings304_19[] = { +Coding x64Parser::OpcodeCodings306_19[] = { { CODING_NAME("outsd") Coding::stateFunc, 5 }, { CODING_NAME("outsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode304(x64Operand &operand) +asmError x64Parser::Opcode306(x64Operand &operand) { - operand.values[19] = OpcodeCodings304_19; + operand.values[19] = OpcodeCodings306_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode305(x64Operand &operand) +asmError x64Parser::Opcode307(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7777, operand); + asmError rv = ParseOperands(tokenBranches7783, operand); return rv; } -Coding x64Parser::OpcodeCodings306_19[] = { +Coding x64Parser::OpcodeCodings308_19[] = { { CODING_NAME("popa") Coding::stateFunc, 7 }, { CODING_NAME("popa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode306(x64Operand &operand) +asmError x64Parser::Opcode308(x64Operand &operand) { - operand.values[19] = OpcodeCodings306_19; + operand.values[19] = OpcodeCodings308_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings307_19[] = { +Coding x64Parser::OpcodeCodings309_19[] = { { CODING_NAME("popaw") Coding::stateFunc, 7 }, { CODING_NAME("popaw") Coding::stateFunc, 4 }, { CODING_NAME("popaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode307(x64Operand &operand) +asmError x64Parser::Opcode309(x64Operand &operand) { - operand.values[19] = OpcodeCodings307_19; + operand.values[19] = OpcodeCodings309_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings308_19[] = { +Coding x64Parser::OpcodeCodings310_19[] = { { CODING_NAME("popad") Coding::stateFunc, 7 }, { CODING_NAME("popad") Coding::stateFunc, 5 }, { CODING_NAME("popad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode308(x64Operand &operand) +asmError x64Parser::Opcode310(x64Operand &operand) { - operand.values[19] = OpcodeCodings308_19; + operand.values[19] = OpcodeCodings310_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings309_23[] = { +Coding x64Parser::OpcodeCodings311_23[] = { { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings309_36[] = { +Coding x64Parser::OpcodeCodings311_36[] = { { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("popcnt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 184, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode309(x64Operand &operand) +asmError x64Parser::Opcode311(x64Operand &operand) { - operand.values[23] = OpcodeCodings309_23; - operand.values[36] = OpcodeCodings309_36; + operand.values[23] = OpcodeCodings311_23; + operand.values[36] = OpcodeCodings311_36; asmError rv; { rv = Opcode2(operand); } return rv; } -Coding x64Parser::OpcodeCodings310_19[] = { +Coding x64Parser::OpcodeCodings312_19[] = { { CODING_NAME("popf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode310(x64Operand &operand) +asmError x64Parser::Opcode312(x64Operand &operand) { - operand.values[19] = OpcodeCodings310_19; + operand.values[19] = OpcodeCodings312_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings311_19[] = { +Coding x64Parser::OpcodeCodings313_19[] = { { CODING_NAME("popfw") Coding::stateFunc, 4 }, { CODING_NAME("popfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode311(x64Operand &operand) +asmError x64Parser::Opcode313(x64Operand &operand) { - operand.values[19] = OpcodeCodings311_19; + operand.values[19] = OpcodeCodings313_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings312_19[] = { +Coding x64Parser::OpcodeCodings314_19[] = { { CODING_NAME("popfd") Coding::stateFunc, 5 }, { CODING_NAME("popfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode312(x64Operand &operand) +asmError x64Parser::Opcode314(x64Operand &operand) { - operand.values[19] = OpcodeCodings312_19; + operand.values[19] = OpcodeCodings314_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings313_19[] = { +Coding x64Parser::OpcodeCodings315_19[] = { { CODING_NAME("popfq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 157, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode313(x64Operand &operand) +asmError x64Parser::Opcode315(x64Operand &operand) { - operand.values[19] = OpcodeCodings313_19; + operand.values[19] = OpcodeCodings315_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode314(x64Operand &operand) +asmError x64Parser::Opcode316(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7798, operand); + asmError rv = ParseOperands(tokenBranches7804, operand); return rv; } -asmError x64Parser::Opcode315(x64Operand &operand) +asmError x64Parser::Opcode317(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7800, operand); + asmError rv = ParseOperands(tokenBranches7806, operand); return rv; } -asmError x64Parser::Opcode316(x64Operand &operand) +asmError x64Parser::Opcode318(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7802, operand); + asmError rv = ParseOperands(tokenBranches7808, operand); return rv; } -asmError x64Parser::Opcode317(x64Operand &operand) +asmError x64Parser::Opcode319(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7804, operand); + asmError rv = ParseOperands(tokenBranches7810, operand); return rv; } -asmError x64Parser::Opcode318(x64Operand &operand) +asmError x64Parser::Opcode320(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7806, operand); + asmError rv = ParseOperands(tokenBranches7812, operand); return rv; } -Coding x64Parser::OpcodeCodings319_19[] = { +Coding x64Parser::OpcodeCodings321_19[] = { { CODING_NAME("pusha") Coding::stateFunc, 7 }, { CODING_NAME("pusha") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode319(x64Operand &operand) +asmError x64Parser::Opcode321(x64Operand &operand) { - operand.values[19] = OpcodeCodings319_19; + operand.values[19] = OpcodeCodings321_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings320_19[] = { +Coding x64Parser::OpcodeCodings322_19[] = { { CODING_NAME("pushaw") Coding::stateFunc, 7 }, { CODING_NAME("pushaw") Coding::stateFunc, 4 }, { CODING_NAME("pushaw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode320(x64Operand &operand) +asmError x64Parser::Opcode322(x64Operand &operand) { - operand.values[19] = OpcodeCodings320_19; + operand.values[19] = OpcodeCodings322_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings321_19[] = { +Coding x64Parser::OpcodeCodings323_19[] = { { CODING_NAME("pushad") Coding::stateFunc, 7 }, { CODING_NAME("pushad") Coding::stateFunc, 5 }, { CODING_NAME("pushad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode321(x64Operand &operand) +asmError x64Parser::Opcode323(x64Operand &operand) { - operand.values[19] = OpcodeCodings321_19; + operand.values[19] = OpcodeCodings323_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings322_19[] = { +Coding x64Parser::OpcodeCodings324_19[] = { { CODING_NAME("pushf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode322(x64Operand &operand) +asmError x64Parser::Opcode324(x64Operand &operand) { - operand.values[19] = OpcodeCodings322_19; + operand.values[19] = OpcodeCodings324_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings323_19[] = { +Coding x64Parser::OpcodeCodings325_19[] = { { CODING_NAME("pushfw") Coding::stateFunc, 4 }, { CODING_NAME("pushfw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode323(x64Operand &operand) +asmError x64Parser::Opcode325(x64Operand &operand) { - operand.values[19] = OpcodeCodings323_19; + operand.values[19] = OpcodeCodings325_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings324_19[] = { +Coding x64Parser::OpcodeCodings326_19[] = { { CODING_NAME("pushfd") Coding::stateFunc, 5 }, { CODING_NAME("pushfd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 156, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode324(x64Operand &operand) +asmError x64Parser::Opcode326(x64Operand &operand) { - operand.values[19] = OpcodeCodings324_19; + operand.values[19] = OpcodeCodings326_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings325_19[] = { +Coding x64Parser::OpcodeCodings327_19[] = { { CODING_NAME("pushfq") (Coding::Type)(Coding::valSpecified), 156, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode325(x64Operand &operand) +asmError x64Parser::Opcode327(x64Operand &operand) { - operand.values[19] = OpcodeCodings325_19; + operand.values[19] = OpcodeCodings327_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings326_18[] = { +Coding x64Parser::OpcodeCodings328_18[] = { { CODING_NAME("rcl") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode326(x64Operand &operand) +asmError x64Parser::Opcode328(x64Operand &operand) { - operand.values[18] = OpcodeCodings326_18; + operand.values[18] = OpcodeCodings328_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings327_18[] = { +Coding x64Parser::OpcodeCodings329_18[] = { { CODING_NAME("rcr") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode327(x64Operand &operand) +asmError x64Parser::Opcode329(x64Operand &operand) { - operand.values[18] = OpcodeCodings327_18; + operand.values[18] = OpcodeCodings329_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings328_19[] = { +Coding x64Parser::OpcodeCodings330_19[] = { { CODING_NAME("rdmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 50, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode328(x64Operand &operand) +asmError x64Parser::Opcode330(x64Operand &operand) { - operand.values[19] = OpcodeCodings328_19; + operand.values[19] = OpcodeCodings330_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings329_19[] = { +Coding x64Parser::OpcodeCodings331_19[] = { { CODING_NAME("rdpmc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 51, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode329(x64Operand &operand) +asmError x64Parser::Opcode331(x64Operand &operand) { - operand.values[19] = OpcodeCodings329_19; + operand.values[19] = OpcodeCodings331_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings330_19[] = { +Coding x64Parser::OpcodeCodings332_19[] = { { CODING_NAME("rdtsc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 49, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode330(x64Operand &operand) +asmError x64Parser::Opcode332(x64Operand &operand) { - operand.values[19] = OpcodeCodings330_19; + operand.values[19] = OpcodeCodings332_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode331(x64Operand &operand) +asmError x64Parser::Opcode333(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7842, operand); + asmError rv = ParseOperands(tokenBranches7848, operand); return rv; } -asmError x64Parser::Opcode332(x64Operand &operand) +asmError x64Parser::Opcode334(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7845, operand); + asmError rv = ParseOperands(tokenBranches7851, operand); return rv; } -Coding x64Parser::OpcodeCodings333_18[] = { +Coding x64Parser::OpcodeCodings335_18[] = { { CODING_NAME("rol") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode333(x64Operand &operand) +asmError x64Parser::Opcode335(x64Operand &operand) { - operand.values[18] = OpcodeCodings333_18; + operand.values[18] = OpcodeCodings335_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings334_18[] = { +Coding x64Parser::OpcodeCodings336_18[] = { { CODING_NAME("ror") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode334(x64Operand &operand) +asmError x64Parser::Opcode336(x64Operand &operand) { - operand.values[18] = OpcodeCodings334_18; + operand.values[18] = OpcodeCodings336_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings335_19[] = { +Coding x64Parser::OpcodeCodings337_19[] = { { CODING_NAME("rsm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode335(x64Operand &operand) +asmError x64Parser::Opcode337(x64Operand &operand) { - operand.values[19] = OpcodeCodings335_19; + operand.values[19] = OpcodeCodings337_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings336_19[] = { +Coding x64Parser::OpcodeCodings338_19[] = { { CODING_NAME("sahf") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 158, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode336(x64Operand &operand) +asmError x64Parser::Opcode338(x64Operand &operand) { - operand.values[19] = OpcodeCodings336_19; + operand.values[19] = OpcodeCodings338_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings337_18[] = { +Coding x64Parser::OpcodeCodings339_18[] = { { CODING_NAME("sal") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode337(x64Operand &operand) +asmError x64Parser::Opcode339(x64Operand &operand) { - operand.values[18] = OpcodeCodings337_18; + operand.values[18] = OpcodeCodings339_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings338_18[] = { +Coding x64Parser::OpcodeCodings340_18[] = { { CODING_NAME("sar") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode338(x64Operand &operand) +asmError x64Parser::Opcode340(x64Operand &operand) { - operand.values[18] = OpcodeCodings338_18; + operand.values[18] = OpcodeCodings340_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings339_18[] = { +Coding x64Parser::OpcodeCodings341_18[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings339_36[] = { +Coding x64Parser::OpcodeCodings341_36[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 28, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings339_37[] = { +Coding x64Parser::OpcodeCodings341_37[] = { { CODING_NAME("sbb") (Coding::Type)(Coding::valSpecified), 24, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode339(x64Operand &operand) +asmError x64Parser::Opcode341(x64Operand &operand) { - operand.values[18] = OpcodeCodings339_18; - operand.values[36] = OpcodeCodings339_36; - operand.values[37] = OpcodeCodings339_37; + operand.values[18] = OpcodeCodings341_18; + operand.values[36] = OpcodeCodings341_36; + operand.values[37] = OpcodeCodings341_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode340(x64Operand &operand) +asmError x64Parser::Opcode342(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches7855, operand); + asmError rv = ParseOperands(tokenBranches7861, operand); return rv; } -Coding x64Parser::OpcodeCodings341_19[] = { +Coding x64Parser::OpcodeCodings343_19[] = { { CODING_NAME("scasb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode341(x64Operand &operand) +asmError x64Parser::Opcode343(x64Operand &operand) { - operand.values[19] = OpcodeCodings341_19; + operand.values[19] = OpcodeCodings343_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings342_19[] = { +Coding x64Parser::OpcodeCodings344_19[] = { { CODING_NAME("scasw") Coding::stateFunc, 4 }, { CODING_NAME("scasw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode342(x64Operand &operand) +asmError x64Parser::Opcode344(x64Operand &operand) { - operand.values[19] = OpcodeCodings342_19; + operand.values[19] = OpcodeCodings344_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings343_19[] = { +Coding x64Parser::OpcodeCodings345_19[] = { { CODING_NAME("scasd") Coding::stateFunc, 5 }, { CODING_NAME("scasd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode343(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings343_19; - asmError rv; - { - rv = Opcode0(operand); - } - return rv; -} -asmError x64Parser::Opcode344(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches7983, operand); - return rv; -} -Coding x64Parser::OpcodeCodings345_38[] = { - { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode345(x64Operand &operand) { - operand.values[38] = OpcodeCodings345_38; + operand.values[19] = OpcodeCodings345_19; asmError rv; { - rv = Opcode14(operand); + rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings346_38[] = { - { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode346(x64Operand &operand) { - operand.values[38] = OpcodeCodings346_38; - asmError rv; - { - rv = Opcode14(operand); - } + asmError rv = ParseOperands(tokenBranches7989, operand); return rv; } Coding x64Parser::OpcodeCodings347_38[] = { - { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("seta") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode347(x64Operand &operand) @@ -42089,7 +42142,7 @@ asmError x64Parser::Opcode347(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings348_38[] = { - { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("setae") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode348(x64Operand &operand) @@ -42102,7 +42155,7 @@ asmError x64Parser::Opcode348(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings349_38[] = { - { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("setb") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode349(x64Operand &operand) @@ -42115,7 +42168,7 @@ asmError x64Parser::Opcode349(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings350_38[] = { - { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("setbe") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode350(x64Operand &operand) @@ -42128,7 +42181,7 @@ asmError x64Parser::Opcode350(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings351_38[] = { - { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("setc") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode351(x64Operand &operand) @@ -42141,7 +42194,7 @@ asmError x64Parser::Opcode351(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings352_38[] = { - { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("sete") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode352(x64Operand &operand) @@ -42154,7 +42207,7 @@ asmError x64Parser::Opcode352(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings353_38[] = { - { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("setg") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode353(x64Operand &operand) @@ -42167,7 +42220,7 @@ asmError x64Parser::Opcode353(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings354_38[] = { - { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("setge") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode354(x64Operand &operand) @@ -42180,7 +42233,7 @@ asmError x64Parser::Opcode354(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings355_38[] = { - { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("setl") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode355(x64Operand &operand) @@ -42193,7 +42246,7 @@ asmError x64Parser::Opcode355(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings356_38[] = { - { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("setle") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode356(x64Operand &operand) @@ -42206,7 +42259,7 @@ asmError x64Parser::Opcode356(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings357_38[] = { - { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("setna") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode357(x64Operand &operand) @@ -42219,7 +42272,7 @@ asmError x64Parser::Opcode357(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings358_38[] = { - { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, + { CODING_NAME("setnae") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode358(x64Operand &operand) @@ -42232,7 +42285,7 @@ asmError x64Parser::Opcode358(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings359_38[] = { - { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, + { CODING_NAME("setnb") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode359(x64Operand &operand) @@ -42245,7 +42298,7 @@ asmError x64Parser::Opcode359(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings360_38[] = { - { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("setnbe") (Coding::Type)(Coding::valSpecified), 7, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode360(x64Operand &operand) @@ -42258,7 +42311,7 @@ asmError x64Parser::Opcode360(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings361_38[] = { - { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, + { CODING_NAME("setnc") (Coding::Type)(Coding::valSpecified), 3, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode361(x64Operand &operand) @@ -42271,7 +42324,7 @@ asmError x64Parser::Opcode361(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings362_38[] = { - { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, + { CODING_NAME("setne") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode362(x64Operand &operand) @@ -42284,7 +42337,7 @@ asmError x64Parser::Opcode362(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings363_38[] = { - { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, + { CODING_NAME("setng") (Coding::Type)(Coding::valSpecified), 14, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode363(x64Operand &operand) @@ -42297,7 +42350,7 @@ asmError x64Parser::Opcode363(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings364_38[] = { - { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, + { CODING_NAME("setnge") (Coding::Type)(Coding::valSpecified), 12, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode364(x64Operand &operand) @@ -42310,7 +42363,7 @@ asmError x64Parser::Opcode364(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings365_38[] = { - { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, + { CODING_NAME("setnl") (Coding::Type)(Coding::valSpecified), 13, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode365(x64Operand &operand) @@ -42323,7 +42376,7 @@ asmError x64Parser::Opcode365(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings366_38[] = { - { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("setnle") (Coding::Type)(Coding::valSpecified), 15, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode366(x64Operand &operand) @@ -42336,7 +42389,7 @@ asmError x64Parser::Opcode366(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings367_38[] = { - { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, + { CODING_NAME("setno") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode367(x64Operand &operand) @@ -42349,7 +42402,7 @@ asmError x64Parser::Opcode367(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings368_38[] = { - { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, + { CODING_NAME("setnp") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode368(x64Operand &operand) @@ -42362,7 +42415,7 @@ asmError x64Parser::Opcode368(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings369_38[] = { - { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, + { CODING_NAME("setns") (Coding::Type)(Coding::valSpecified), 9, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode369(x64Operand &operand) @@ -42375,7 +42428,7 @@ asmError x64Parser::Opcode369(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings370_38[] = { - { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("setnz") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode370(x64Operand &operand) @@ -42388,7 +42441,7 @@ asmError x64Parser::Opcode370(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings371_38[] = { - { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, + { CODING_NAME("seto") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode371(x64Operand &operand) @@ -42401,7 +42454,7 @@ asmError x64Parser::Opcode371(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings372_38[] = { - { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, + { CODING_NAME("setp") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode372(x64Operand &operand) @@ -42414,7 +42467,7 @@ asmError x64Parser::Opcode372(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings373_38[] = { - { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("setpe") (Coding::Type)(Coding::valSpecified), 10, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode373(x64Operand &operand) @@ -42427,7 +42480,7 @@ asmError x64Parser::Opcode373(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings374_38[] = { - { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("setpo") (Coding::Type)(Coding::valSpecified), 11, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode374(x64Operand &operand) @@ -42439,545 +42492,534 @@ asmError x64Parser::Opcode374(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings375_19[] = { +Coding x64Parser::OpcodeCodings375_38[] = { + { CODING_NAME("sets") (Coding::Type)(Coding::valSpecified), 8, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode375(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings375_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings376_38[] = { + { CODING_NAME("setz") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +asmError x64Parser::Opcode376(x64Operand &operand) +{ + operand.values[38] = OpcodeCodings376_38; + asmError rv; + { + rv = Opcode14(operand); + } + return rv; +} +Coding x64Parser::OpcodeCodings377_19[] = { { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("sfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode375(x64Operand &operand) +asmError x64Parser::Opcode377(x64Operand &operand) { - operand.values[19] = OpcodeCodings375_19; + operand.values[19] = OpcodeCodings377_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings376_18[] = { +Coding x64Parser::OpcodeCodings378_18[] = { { CODING_NAME("sgdt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings376_19[] = { +Coding x64Parser::OpcodeCodings378_19[] = { { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sgdt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode376(x64Operand &operand) +asmError x64Parser::Opcode378(x64Operand &operand) { - operand.values[18] = OpcodeCodings376_18; - operand.values[19] = OpcodeCodings376_19; + operand.values[18] = OpcodeCodings378_18; + operand.values[19] = OpcodeCodings378_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings377_18[] = { +Coding x64Parser::OpcodeCodings379_18[] = { { CODING_NAME("shl") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode377(x64Operand &operand) +asmError x64Parser::Opcode379(x64Operand &operand) { - operand.values[18] = OpcodeCodings377_18; + operand.values[18] = OpcodeCodings379_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings378_36[] = { +Coding x64Parser::OpcodeCodings380_36[] = { { CODING_NAME("shld") (Coding::Type)(Coding::valSpecified), 164, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode378(x64Operand &operand) +asmError x64Parser::Opcode380(x64Operand &operand) { - operand.values[36] = OpcodeCodings378_36; + operand.values[36] = OpcodeCodings380_36; asmError rv; { rv = Opcode17(operand); } return rv; } -Coding x64Parser::OpcodeCodings379_18[] = { +Coding x64Parser::OpcodeCodings381_18[] = { { CODING_NAME("shr") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode379(x64Operand &operand) +asmError x64Parser::Opcode381(x64Operand &operand) { - operand.values[18] = OpcodeCodings379_18; + operand.values[18] = OpcodeCodings381_18; asmError rv; { rv = Opcode16(operand); } return rv; } -Coding x64Parser::OpcodeCodings380_36[] = { +Coding x64Parser::OpcodeCodings382_36[] = { { CODING_NAME("shrd") (Coding::Type)(Coding::valSpecified), 172, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode380(x64Operand &operand) +asmError x64Parser::Opcode382(x64Operand &operand) { - operand.values[36] = OpcodeCodings380_36; + operand.values[36] = OpcodeCodings382_36; asmError rv; { rv = Opcode17(operand); } return rv; } -Coding x64Parser::OpcodeCodings381_18[] = { +Coding x64Parser::OpcodeCodings383_18[] = { { CODING_NAME("sidt") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings381_19[] = { +Coding x64Parser::OpcodeCodings383_19[] = { { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sidt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode381(x64Operand &operand) +asmError x64Parser::Opcode383(x64Operand &operand) { - operand.values[18] = OpcodeCodings381_18; - operand.values[19] = OpcodeCodings381_19; + operand.values[18] = OpcodeCodings383_18; + operand.values[19] = OpcodeCodings383_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings382_18[] = { +Coding x64Parser::OpcodeCodings384_18[] = { { CODING_NAME("sldt") (Coding::Type)(Coding::valSpecified), 0, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings382_19[] = { +Coding x64Parser::OpcodeCodings384_19[] = { { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("sldt") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode382(x64Operand &operand) +asmError x64Parser::Opcode384(x64Operand &operand) { - operand.values[18] = OpcodeCodings382_18; - operand.values[19] = OpcodeCodings382_19; + operand.values[18] = OpcodeCodings384_18; + operand.values[19] = OpcodeCodings384_19; asmError rv; { rv = Opcode18(operand); } return rv; } -Coding x64Parser::OpcodeCodings383_18[] = { +Coding x64Parser::OpcodeCodings385_18[] = { { CODING_NAME("smsw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings383_19[] = { +Coding x64Parser::OpcodeCodings385_19[] = { { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("smsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode383(x64Operand &operand) +asmError x64Parser::Opcode385(x64Operand &operand) { - operand.values[18] = OpcodeCodings383_18; - operand.values[19] = OpcodeCodings383_19; - asmError rv = ParseOperands(tokenBranches8023, operand); + operand.values[18] = OpcodeCodings385_18; + operand.values[19] = OpcodeCodings385_19; + asmError rv = ParseOperands(tokenBranches8029, operand); return rv; } -Coding x64Parser::OpcodeCodings384_19[] = { +Coding x64Parser::OpcodeCodings386_19[] = { { CODING_NAME("stc") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 249, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode384(x64Operand &operand) +asmError x64Parser::Opcode386(x64Operand &operand) { - operand.values[19] = OpcodeCodings384_19; + operand.values[19] = OpcodeCodings386_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings385_19[] = { +Coding x64Parser::OpcodeCodings387_19[] = { { CODING_NAME("std") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode385(x64Operand &operand) +asmError x64Parser::Opcode387(x64Operand &operand) { - operand.values[19] = OpcodeCodings385_19; + operand.values[19] = OpcodeCodings387_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings386_19[] = { +Coding x64Parser::OpcodeCodings388_19[] = { { CODING_NAME("sti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode386(x64Operand &operand) +asmError x64Parser::Opcode388(x64Operand &operand) { - operand.values[19] = OpcodeCodings386_19; + operand.values[19] = OpcodeCodings388_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode387(x64Operand &operand) +asmError x64Parser::Opcode389(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8028, operand); + asmError rv = ParseOperands(tokenBranches8034, operand); return rv; } -Coding x64Parser::OpcodeCodings388_19[] = { +Coding x64Parser::OpcodeCodings390_19[] = { { CODING_NAME("stosb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode388(x64Operand &operand) +asmError x64Parser::Opcode390(x64Operand &operand) { - operand.values[19] = OpcodeCodings388_19; + operand.values[19] = OpcodeCodings390_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings389_19[] = { +Coding x64Parser::OpcodeCodings391_19[] = { { CODING_NAME("stosw") Coding::stateFunc, 4 }, { CODING_NAME("stosw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode389(x64Operand &operand) +asmError x64Parser::Opcode391(x64Operand &operand) { - operand.values[19] = OpcodeCodings389_19; + operand.values[19] = OpcodeCodings391_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings390_19[] = { +Coding x64Parser::OpcodeCodings392_19[] = { { CODING_NAME("stosd") Coding::stateFunc, 5 }, { CODING_NAME("stosd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode390(x64Operand &operand) +asmError x64Parser::Opcode392(x64Operand &operand) { - operand.values[19] = OpcodeCodings390_19; + operand.values[19] = OpcodeCodings392_19; asmError rv; { rv = Opcode0(operand); } return rv; } -asmError x64Parser::Opcode391(x64Operand &operand) +asmError x64Parser::Opcode393(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8156, operand); + asmError rv = ParseOperands(tokenBranches8162, operand); return rv; } -Coding x64Parser::OpcodeCodings392_18[] = { +Coding x64Parser::OpcodeCodings394_18[] = { { CODING_NAME("str") (Coding::Type)(Coding::valSpecified), 1, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings392_19[] = { +Coding x64Parser::OpcodeCodings394_19[] = { { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("str") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode392(x64Operand &operand) +asmError x64Parser::Opcode394(x64Operand &operand) { - operand.values[18] = OpcodeCodings392_18; - operand.values[19] = OpcodeCodings392_19; - asmError rv = ParseOperands(tokenBranches8158, operand); + operand.values[18] = OpcodeCodings394_18; + operand.values[19] = OpcodeCodings394_19; + asmError rv = ParseOperands(tokenBranches8164, operand); return rv; } -Coding x64Parser::OpcodeCodings393_18[] = { +Coding x64Parser::OpcodeCodings395_18[] = { { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings393_36[] = { +Coding x64Parser::OpcodeCodings395_36[] = { { CODING_NAME("sub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings393_37[] = { +Coding x64Parser::OpcodeCodings395_37[] = { { CODING_NAME("sub") (Coding::Type)(Coding::valSpecified), 40, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode393(x64Operand &operand) +asmError x64Parser::Opcode395(x64Operand &operand) { - operand.values[18] = OpcodeCodings393_18; - operand.values[36] = OpcodeCodings393_36; - operand.values[37] = OpcodeCodings393_37; + operand.values[18] = OpcodeCodings395_18; + operand.values[36] = OpcodeCodings395_36; + operand.values[37] = OpcodeCodings395_37; asmError rv; { rv = Opcode4(operand); } return rv; } -Coding x64Parser::OpcodeCodings394_19[] = { +Coding x64Parser::OpcodeCodings396_19[] = { { CODING_NAME("syscall") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode394(x64Operand &operand) +asmError x64Parser::Opcode396(x64Operand &operand) { - operand.values[19] = OpcodeCodings394_19; + operand.values[19] = OpcodeCodings396_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings395_19[] = { +Coding x64Parser::OpcodeCodings397_19[] = { { CODING_NAME("sysenter") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode395(x64Operand &operand) +asmError x64Parser::Opcode397(x64Operand &operand) { - operand.values[19] = OpcodeCodings395_19; + operand.values[19] = OpcodeCodings397_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings396_19[] = { +Coding x64Parser::OpcodeCodings398_19[] = { { CODING_NAME("sysexit") (Coding::Type)(Coding::valSpecified), 53, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode396(x64Operand &operand) +asmError x64Parser::Opcode398(x64Operand &operand) { - operand.values[19] = OpcodeCodings396_19; + operand.values[19] = OpcodeCodings398_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings397_19[] = { +Coding x64Parser::OpcodeCodings399_19[] = { { CODING_NAME("sysret") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode397(x64Operand &operand) +asmError x64Parser::Opcode399(x64Operand &operand) { - operand.values[19] = OpcodeCodings397_19; + operand.values[19] = OpcodeCodings399_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode398(x64Operand &operand) +asmError x64Parser::Opcode400(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8167, operand); + asmError rv = ParseOperands(tokenBranches8173, operand); return rv; } -Coding x64Parser::OpcodeCodings399_19[] = { +Coding x64Parser::OpcodeCodings401_19[] = { { CODING_NAME("ud2") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode399(x64Operand &operand) +asmError x64Parser::Opcode401(x64Operand &operand) { - operand.values[19] = OpcodeCodings399_19; + operand.values[19] = OpcodeCodings401_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings400_18[] = { +Coding x64Parser::OpcodeCodings402_18[] = { { CODING_NAME("verr") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings400_19[] = { +Coding x64Parser::OpcodeCodings402_19[] = { { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("verr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode400(x64Operand &operand) +asmError x64Parser::Opcode402(x64Operand &operand) { - operand.values[18] = OpcodeCodings400_18; - operand.values[19] = OpcodeCodings400_19; - asmError rv = ParseOperands(tokenBranches8282, operand); + operand.values[18] = OpcodeCodings402_18; + operand.values[19] = OpcodeCodings402_19; + asmError rv = ParseOperands(tokenBranches8288, operand); return rv; } -Coding x64Parser::OpcodeCodings401_18[] = { +Coding x64Parser::OpcodeCodings403_18[] = { { CODING_NAME("verw") (Coding::Type)(Coding::valSpecified), 5, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings401_19[] = { +Coding x64Parser::OpcodeCodings403_19[] = { { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("verw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode401(x64Operand &operand) +asmError x64Parser::Opcode403(x64Operand &operand) { - operand.values[18] = OpcodeCodings401_18; - operand.values[19] = OpcodeCodings401_19; - asmError rv = ParseOperands(tokenBranches8284, operand); + operand.values[18] = OpcodeCodings403_18; + operand.values[19] = OpcodeCodings403_19; + asmError rv = ParseOperands(tokenBranches8290, operand); return rv; } -Coding x64Parser::OpcodeCodings402_19[] = { +Coding x64Parser::OpcodeCodings404_19[] = { { CODING_NAME("wait") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode402(x64Operand &operand) +asmError x64Parser::Opcode404(x64Operand &operand) { - operand.values[19] = OpcodeCodings402_19; + operand.values[19] = OpcodeCodings404_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings403_19[] = { +Coding x64Parser::OpcodeCodings405_19[] = { { CODING_NAME("wbinvd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode403(x64Operand &operand) +asmError x64Parser::Opcode405(x64Operand &operand) { - operand.values[19] = OpcodeCodings403_19; + operand.values[19] = OpcodeCodings405_19; asmError rv; { rv = Opcode1(operand); } return rv; } -Coding x64Parser::OpcodeCodings404_19[] = { +Coding x64Parser::OpcodeCodings406_19[] = { { CODING_NAME("wrmsr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 48, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode404(x64Operand &operand) +asmError x64Parser::Opcode406(x64Operand &operand) { - operand.values[19] = OpcodeCodings404_19; + operand.values[19] = OpcodeCodings406_19; asmError rv; { rv = Opcode1(operand); } return rv; } -asmError x64Parser::Opcode405(x64Operand &operand) +asmError x64Parser::Opcode407(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8289, operand); + asmError rv = ParseOperands(tokenBranches8295, operand); return rv; } -asmError x64Parser::Opcode406(x64Operand &operand) +asmError x64Parser::Opcode408(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8310, operand); + asmError rv = ParseOperands(tokenBranches8316, operand); return rv; } -asmError x64Parser::Opcode407(x64Operand &operand) +asmError x64Parser::Opcode409(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8369, operand); + asmError rv = ParseOperands(tokenBranches8375, operand); return rv; } -Coding x64Parser::OpcodeCodings408_19[] = { +Coding x64Parser::OpcodeCodings410_19[] = { { CODING_NAME("xlatb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode408(x64Operand &operand) +asmError x64Parser::Opcode410(x64Operand &operand) { - operand.values[19] = OpcodeCodings408_19; + operand.values[19] = OpcodeCodings410_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings409_18[] = { +Coding x64Parser::OpcodeCodings411_18[] = { { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings409_36[] = { +Coding x64Parser::OpcodeCodings411_36[] = { { CODING_NAME("xor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 52, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings409_37[] = { +Coding x64Parser::OpcodeCodings411_37[] = { { CODING_NAME("xor") (Coding::Type)(Coding::valSpecified), 48, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode409(x64Operand &operand) +asmError x64Parser::Opcode411(x64Operand &operand) { - operand.values[18] = OpcodeCodings409_18; - operand.values[36] = OpcodeCodings409_36; - operand.values[37] = OpcodeCodings409_37; + operand.values[18] = OpcodeCodings411_18; + operand.values[36] = OpcodeCodings411_36; + operand.values[37] = OpcodeCodings411_37; asmError rv; { rv = Opcode4(operand); } return rv; } -asmError x64Parser::Opcode410(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches8409, operand); - return rv; -} -asmError x64Parser::Opcode411(x64Operand &operand) -{ - asmError rv = ParseOperands(tokenBranches8411, operand); - return rv; -} asmError x64Parser::Opcode412(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8413, operand); + asmError rv = ParseOperands(tokenBranches8415, operand); return rv; } asmError x64Parser::Opcode413(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8415, operand); + asmError rv = ParseOperands(tokenBranches8417, operand); return rv; } -Coding x64Parser::OpcodeCodings414_19[] = { - { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, - { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode414(x64Operand &operand) { - operand.values[19] = OpcodeCodings414_19; - asmError rv; - { - rv = Opcode1(operand); - } + asmError rv = ParseOperands(tokenBranches8419, operand); return rv; } -Coding x64Parser::OpcodeCodings415_23[] = { - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings415_19[] = { - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode415(x64Operand &operand) { - operand.values[23] = OpcodeCodings415_23; - operand.values[19] = OpcodeCodings415_19; - asmError rv; - { - rv = Opcode19(operand); - } + asmError rv = ParseOperands(tokenBranches8421, operand); return rv; } -Coding x64Parser::OpcodeCodings416_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings416_19[] = { - { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, + { CODING_NAME("xsetbv") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 209, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode416(x64Operand &operand) { - operand.values[23] = OpcodeCodings416_23; operand.values[19] = OpcodeCodings416_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode1(operand); } return rv; } Coding x64Parser::OpcodeCodings417_23[] = { - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings417_19[] = { - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode417(x64Operand &operand) @@ -42991,12 +43033,11 @@ asmError x64Parser::Opcode417(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings418_23[] = { - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings418_19[] = { - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode418(x64Operand &operand) @@ -43010,12 +43051,12 @@ asmError x64Parser::Opcode418(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings419_23[] = { - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings419_19[] = { - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode419(x64Operand &operand) @@ -43029,12 +43070,12 @@ asmError x64Parser::Opcode419(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings420_23[] = { - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings420_19[] = { - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 88, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode420(x64Operand &operand) @@ -43048,12 +43089,12 @@ asmError x64Parser::Opcode420(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings421_23[] = { - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings421_19[] = { - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode421(x64Operand &operand) @@ -43067,11 +43108,12 @@ asmError x64Parser::Opcode421(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings422_23[] = { + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings422_19[] = { - { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("addsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 208, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode422(x64Operand &operand) @@ -43085,12 +43127,12 @@ asmError x64Parser::Opcode422(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings423_23[] = { - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings423_19[] = { - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode423(x64Operand &operand) @@ -43107,8 +43149,8 @@ Coding x64Parser::OpcodeCodings424_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings424_19[] = { - { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andnps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 85, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode424(x64Operand &operand) @@ -43122,13 +43164,12 @@ asmError x64Parser::Opcode424(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings425_23[] = { - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings425_19[] = { - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode425(x64Operand &operand) @@ -43137,18 +43178,16 @@ asmError x64Parser::Opcode425(x64Operand &operand) operand.values[19] = OpcodeCodings425_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings426_23[] = { - { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings426_19[] = { - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("andps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 84, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode426(x64Operand &operand) @@ -43157,17 +43196,18 @@ asmError x64Parser::Opcode426(x64Operand &operand) operand.values[19] = OpcodeCodings426_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings427_23[] = { - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings427_19[] = { - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 13, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode427(x64Operand &operand) @@ -43176,16 +43216,18 @@ asmError x64Parser::Opcode427(x64Operand &operand) operand.values[19] = OpcodeCodings427_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings428_23[] = { + { CODING_NAME("blendps") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings428_19[] = { - { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("blendps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 12, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode428(x64Operand &operand) @@ -43194,17 +43236,17 @@ asmError x64Parser::Opcode428(x64Operand &operand) operand.values[19] = OpcodeCodings428_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings429_23[] = { - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings429_19[] = { - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode429(x64Operand &operand) @@ -43213,7 +43255,7 @@ asmError x64Parser::Opcode429(x64Operand &operand) operand.values[19] = OpcodeCodings429_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode28(operand); } return rv; } @@ -43221,8 +43263,8 @@ Coding x64Parser::OpcodeCodings430_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings430_19[] = { - { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cmpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode430(x64Operand &operand) @@ -43231,17 +43273,17 @@ asmError x64Parser::Opcode430(x64Operand &operand) operand.values[19] = OpcodeCodings430_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode28(operand); } return rv; } Coding x64Parser::OpcodeCodings431_23[] = { - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings431_19[] = { - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode431(x64Operand &operand) @@ -43258,8 +43300,8 @@ Coding x64Parser::OpcodeCodings432_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings432_19[] = { - { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("comiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 47, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode432(x64Operand &operand) @@ -43273,12 +43315,12 @@ asmError x64Parser::Opcode432(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings433_23[] = { - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings433_19[] = { - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode433(x64Operand &operand) @@ -43292,12 +43334,11 @@ asmError x64Parser::Opcode433(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings434_23[] = { - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings434_19[] = { - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtdq2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode434(x64Operand &operand) @@ -43306,17 +43347,17 @@ asmError x64Parser::Opcode434(x64Operand &operand) operand.values[19] = OpcodeCodings434_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings435_23[] = { - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings435_19[] = { - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode435(x64Operand &operand) @@ -43330,12 +43371,12 @@ asmError x64Parser::Opcode435(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings436_23[] = { - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings436_19[] = { - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode436(x64Operand &operand) @@ -43344,16 +43385,17 @@ asmError x64Parser::Opcode436(x64Operand &operand) operand.values[19] = OpcodeCodings436_19; asmError rv; { - rv = Opcode24(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings437_23[] = { + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings437_19[] = { - { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpd2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode437(x64Operand &operand) @@ -43362,17 +43404,17 @@ asmError x64Parser::Opcode437(x64Operand &operand) operand.values[19] = OpcodeCodings437_19; asmError rv; { - rv = Opcode24(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings438_23[] = { - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings438_19[] = { - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode438(x64Operand &operand) @@ -43381,7 +43423,7 @@ asmError x64Parser::Opcode438(x64Operand &operand) operand.values[19] = OpcodeCodings438_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode24(operand); } return rv; } @@ -43389,8 +43431,8 @@ Coding x64Parser::OpcodeCodings439_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings439_19[] = { - { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtpi2ps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode439(x64Operand &operand) @@ -43399,16 +43441,17 @@ asmError x64Parser::Opcode439(x64Operand &operand) operand.values[19] = OpcodeCodings439_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode24(operand); } return rv; } Coding x64Parser::OpcodeCodings440_23[] = { + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings440_19[] = { - { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode440(x64Operand &operand) @@ -43417,17 +43460,16 @@ asmError x64Parser::Opcode440(x64Operand &operand) operand.values[19] = OpcodeCodings440_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings441_23[] = { - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings441_19[] = { - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode441(x64Operand &operand) @@ -43436,17 +43478,16 @@ asmError x64Parser::Opcode441(x64Operand &operand) operand.values[19] = OpcodeCodings441_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings442_23[] = { - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings442_19[] = { - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode442(x64Operand &operand) @@ -43455,17 +43496,17 @@ asmError x64Parser::Opcode442(x64Operand &operand) operand.values[19] = OpcodeCodings442_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings443_23[] = { - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings443_19[] = { - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode443(x64Operand &operand) @@ -43474,17 +43515,17 @@ asmError x64Parser::Opcode443(x64Operand &operand) operand.values[19] = OpcodeCodings443_19; asmError rv; { - rv = Opcode26(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings444_23[] = { - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings444_19[] = { - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsd2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode444(x64Operand &operand) @@ -43493,17 +43534,17 @@ asmError x64Parser::Opcode444(x64Operand &operand) operand.values[19] = OpcodeCodings444_19; asmError rv; { - rv = Opcode26(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings445_23[] = { - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings445_19[] = { - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode445(x64Operand &operand) @@ -43512,17 +43553,17 @@ asmError x64Parser::Opcode445(x64Operand &operand) operand.values[19] = OpcodeCodings445_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode26(operand); } return rv; } Coding x64Parser::OpcodeCodings446_23[] = { - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings446_19[] = { - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtsi2ss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 42, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode446(x64Operand &operand) @@ -43531,17 +43572,17 @@ asmError x64Parser::Opcode446(x64Operand &operand) operand.values[19] = OpcodeCodings446_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode26(operand); } return rv; } Coding x64Parser::OpcodeCodings447_23[] = { - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings447_19[] = { - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2sd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 90, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode447(x64Operand &operand) @@ -43555,12 +43596,12 @@ asmError x64Parser::Opcode447(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings448_23[] = { - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings448_19[] = { - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvtss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 45, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode448(x64Operand &operand) @@ -43569,17 +43610,17 @@ asmError x64Parser::Opcode448(x64Operand &operand) operand.values[19] = OpcodeCodings448_19; asmError rv; { - rv = Opcode23(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings449_23[] = { - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings449_19[] = { - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode449(x64Operand &operand) @@ -43593,11 +43634,12 @@ asmError x64Parser::Opcode449(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings450_23[] = { + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings450_19[] = { - { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttpd2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode450(x64Operand &operand) @@ -43611,12 +43653,12 @@ asmError x64Parser::Opcode450(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings451_23[] = { - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings451_19[] = { - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2dq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 91, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode451(x64Operand &operand) @@ -43625,17 +43667,16 @@ asmError x64Parser::Opcode451(x64Operand &operand) operand.values[19] = OpcodeCodings451_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings452_23[] = { - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings452_19[] = { - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttps2pi") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode452(x64Operand &operand) @@ -43644,17 +43685,17 @@ asmError x64Parser::Opcode452(x64Operand &operand) operand.values[19] = OpcodeCodings452_19; asmError rv; { - rv = Opcode25(operand); + rv = Opcode23(operand); } return rv; } Coding x64Parser::OpcodeCodings453_23[] = { - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings453_19[] = { - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttsd2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode453(x64Operand &operand) @@ -43663,16 +43704,17 @@ asmError x64Parser::Opcode453(x64Operand &operand) operand.values[19] = OpcodeCodings453_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings454_23[] = { + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings454_19[] = { - { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("cvttss2si") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 44, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode454(x64Operand &operand) @@ -43681,17 +43723,17 @@ asmError x64Parser::Opcode454(x64Operand &operand) operand.values[19] = OpcodeCodings454_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode25(operand); } return rv; } Coding x64Parser::OpcodeCodings455_23[] = { - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings455_19[] = { - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode455(x64Operand &operand) @@ -43705,12 +43747,11 @@ asmError x64Parser::Opcode455(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings456_23[] = { - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings456_19[] = { - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode456(x64Operand &operand) @@ -43724,13 +43765,12 @@ asmError x64Parser::Opcode456(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings457_23[] = { - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings457_19[] = { - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode457(x64Operand &operand) @@ -43739,17 +43779,17 @@ asmError x64Parser::Opcode457(x64Operand &operand) operand.values[19] = OpcodeCodings457_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings458_23[] = { + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings458_19[] = { - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("divss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 94, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode458(x64Operand &operand) @@ -43758,17 +43798,18 @@ asmError x64Parser::Opcode458(x64Operand &operand) operand.values[19] = OpcodeCodings458_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings459_23[] = { - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings459_19[] = { - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dppd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode459(x64Operand &operand) @@ -43777,17 +43818,17 @@ asmError x64Parser::Opcode459(x64Operand &operand) operand.values[19] = OpcodeCodings459_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings460_23[] = { - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings460_19[] = { - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("dpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode460(x64Operand &operand) @@ -43796,18 +43837,17 @@ asmError x64Parser::Opcode460(x64Operand &operand) operand.values[19] = OpcodeCodings460_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings461_23[] = { - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings461_19[] = { - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode461(x64Operand &operand) @@ -43816,17 +43856,17 @@ asmError x64Parser::Opcode461(x64Operand &operand) operand.values[19] = OpcodeCodings461_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings462_23[] = { - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings462_19[] = { - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("hsubps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 125, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode462(x64Operand &operand) @@ -43839,1176 +43879,1187 @@ asmError x64Parser::Opcode462(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings463_23[] = { + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings463_19[] = { + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("insertps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 33, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode463(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8466, operand); + operand.values[23] = OpcodeCodings463_23; + operand.values[19] = OpcodeCodings463_19; + asmError rv; + { + rv = Opcode30(operand); + } return rv; } +Coding x64Parser::OpcodeCodings464_23[] = { + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings464_19[] = { + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("lddqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode464(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8470, operand); + operand.values[23] = OpcodeCodings464_23; + operand.values[19] = OpcodeCodings464_19; + asmError rv; + { + rv = Opcode19(operand); + } + return rv; +} +asmError x64Parser::Opcode465(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches8472, operand); + return rv; +} +asmError x64Parser::Opcode466(x64Operand &operand) +{ + asmError rv = ParseOperands(tokenBranches8476, operand); return rv; } -Coding x64Parser::OpcodeCodings465_23[] = { +Coding x64Parser::OpcodeCodings467_23[] = { { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings465_19[] = { +Coding x64Parser::OpcodeCodings467_19[] = { { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode465(x64Operand &operand) +asmError x64Parser::Opcode467(x64Operand &operand) { - operand.values[23] = OpcodeCodings465_23; - operand.values[19] = OpcodeCodings465_19; + operand.values[23] = OpcodeCodings467_23; + operand.values[19] = OpcodeCodings467_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings466_23[] = { +Coding x64Parser::OpcodeCodings468_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings466_19[] = { +Coding x64Parser::OpcodeCodings468_19[] = { { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode466(x64Operand &operand) +asmError x64Parser::Opcode468(x64Operand &operand) { - operand.values[23] = OpcodeCodings466_23; - operand.values[19] = OpcodeCodings466_19; + operand.values[23] = OpcodeCodings468_23; + operand.values[19] = OpcodeCodings468_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings467_23[] = { +Coding x64Parser::OpcodeCodings469_23[] = { { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings467_19[] = { +Coding x64Parser::OpcodeCodings469_19[] = { { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode467(x64Operand &operand) +asmError x64Parser::Opcode469(x64Operand &operand) { - operand.values[23] = OpcodeCodings467_23; - operand.values[19] = OpcodeCodings467_19; + operand.values[23] = OpcodeCodings469_23; + operand.values[19] = OpcodeCodings469_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings468_23[] = { +Coding x64Parser::OpcodeCodings470_23[] = { { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings468_19[] = { +Coding x64Parser::OpcodeCodings470_19[] = { { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("maxss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 95, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode468(x64Operand &operand) +asmError x64Parser::Opcode470(x64Operand &operand) { - operand.values[23] = OpcodeCodings468_23; - operand.values[19] = OpcodeCodings468_19; + operand.values[23] = OpcodeCodings470_23; + operand.values[19] = OpcodeCodings470_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings469_19[] = { +Coding x64Parser::OpcodeCodings471_19[] = { { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("mfence") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 240, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode469(x64Operand &operand) +asmError x64Parser::Opcode471(x64Operand &operand) { - operand.values[19] = OpcodeCodings469_19; + operand.values[19] = OpcodeCodings471_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings470_19[] = { +Coding x64Parser::OpcodeCodings472_19[] = { { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("pause") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 144, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode470(x64Operand &operand) +asmError x64Parser::Opcode472(x64Operand &operand) { - operand.values[19] = OpcodeCodings470_19; + operand.values[19] = OpcodeCodings472_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings471_23[] = { +Coding x64Parser::OpcodeCodings473_23[] = { { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings471_19[] = { +Coding x64Parser::OpcodeCodings473_19[] = { { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode471(x64Operand &operand) +asmError x64Parser::Opcode473(x64Operand &operand) { - operand.values[23] = OpcodeCodings471_23; - operand.values[19] = OpcodeCodings471_19; + operand.values[23] = OpcodeCodings473_23; + operand.values[19] = OpcodeCodings473_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings472_23[] = { +Coding x64Parser::OpcodeCodings474_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings472_19[] = { +Coding x64Parser::OpcodeCodings474_19[] = { { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode472(x64Operand &operand) +asmError x64Parser::Opcode474(x64Operand &operand) { - operand.values[23] = OpcodeCodings472_23; - operand.values[19] = OpcodeCodings472_19; + operand.values[23] = OpcodeCodings474_23; + operand.values[19] = OpcodeCodings474_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings473_23[] = { +Coding x64Parser::OpcodeCodings475_23[] = { { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings473_19[] = { +Coding x64Parser::OpcodeCodings475_19[] = { { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode473(x64Operand &operand) +asmError x64Parser::Opcode475(x64Operand &operand) { - operand.values[23] = OpcodeCodings473_23; - operand.values[19] = OpcodeCodings473_19; + operand.values[23] = OpcodeCodings475_23; + operand.values[19] = OpcodeCodings475_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings474_23[] = { +Coding x64Parser::OpcodeCodings476_23[] = { { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings474_19[] = { +Coding x64Parser::OpcodeCodings476_19[] = { { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("minss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 93, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode474(x64Operand &operand) +asmError x64Parser::Opcode476(x64Operand &operand) { - operand.values[23] = OpcodeCodings474_23; - operand.values[19] = OpcodeCodings474_19; + operand.values[23] = OpcodeCodings476_23; + operand.values[19] = OpcodeCodings476_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings475_19[] = { +Coding x64Parser::OpcodeCodings477_19[] = { { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 1, 8, 0, 0, 0 }, { CODING_NAME("monitor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode475(x64Operand &operand) +asmError x64Parser::Opcode477(x64Operand &operand) { - operand.values[19] = OpcodeCodings475_19; + operand.values[19] = OpcodeCodings477_19; asmError rv; { rv = Opcode0(operand); } return rv; } -Coding x64Parser::OpcodeCodings476_23[] = { +Coding x64Parser::OpcodeCodings478_23[] = { { CODING_NAME("movapd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings476_36[] = { +Coding x64Parser::OpcodeCodings478_36[] = { { CODING_NAME("movapd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode476(x64Operand &operand) +asmError x64Parser::Opcode478(x64Operand &operand) { - operand.values[23] = OpcodeCodings476_23; - operand.values[36] = OpcodeCodings476_36; + operand.values[23] = OpcodeCodings478_23; + operand.values[36] = OpcodeCodings478_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings477_23[] = { +Coding x64Parser::OpcodeCodings479_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings477_36[] = { +Coding x64Parser::OpcodeCodings479_36[] = { { CODING_NAME("movaps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 40, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode477(x64Operand &operand) +asmError x64Parser::Opcode479(x64Operand &operand) { - operand.values[23] = OpcodeCodings477_23; - operand.values[36] = OpcodeCodings477_36; + operand.values[23] = OpcodeCodings479_23; + operand.values[36] = OpcodeCodings479_36; asmError rv; { rv = Opcode20(operand); } return rv; } -asmError x64Parser::Opcode478(x64Operand &operand) +asmError x64Parser::Opcode480(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8487, operand); + asmError rv = ParseOperands(tokenBranches8493, operand); return rv; } -asmError x64Parser::Opcode479(x64Operand &operand) +asmError x64Parser::Opcode481(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8500, operand); + asmError rv = ParseOperands(tokenBranches8506, operand); return rv; } -Coding x64Parser::OpcodeCodings480_23[] = { +Coding x64Parser::OpcodeCodings482_23[] = { { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings480_19[] = { +Coding x64Parser::OpcodeCodings482_19[] = { { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movddup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode480(x64Operand &operand) +asmError x64Parser::Opcode482(x64Operand &operand) { - operand.values[23] = OpcodeCodings480_23; - operand.values[19] = OpcodeCodings480_19; + operand.values[23] = OpcodeCodings482_23; + operand.values[19] = OpcodeCodings482_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings481_23[] = { +Coding x64Parser::OpcodeCodings483_23[] = { { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings481_19[] = { +Coding x64Parser::OpcodeCodings483_19[] = { { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movdq2q") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 214, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode481(x64Operand &operand) +asmError x64Parser::Opcode483(x64Operand &operand) { - operand.values[23] = OpcodeCodings481_23; - operand.values[19] = OpcodeCodings481_19; + operand.values[23] = OpcodeCodings483_23; + operand.values[19] = OpcodeCodings483_19; asmError rv; { rv = Opcode23(operand); } return rv; } -Coding x64Parser::OpcodeCodings482_23[] = { +Coding x64Parser::OpcodeCodings484_23[] = { { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings482_36[] = { +Coding x64Parser::OpcodeCodings484_36[] = { { CODING_NAME("movdqa") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode482(x64Operand &operand) +asmError x64Parser::Opcode484(x64Operand &operand) { - operand.values[23] = OpcodeCodings482_23; - operand.values[36] = OpcodeCodings482_36; + operand.values[23] = OpcodeCodings484_23; + operand.values[36] = OpcodeCodings484_36; asmError rv; { rv = Opcode21(operand); } return rv; } -Coding x64Parser::OpcodeCodings483_23[] = { +Coding x64Parser::OpcodeCodings485_23[] = { { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings483_36[] = { +Coding x64Parser::OpcodeCodings485_36[] = { { CODING_NAME("movdqu") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode483(x64Operand &operand) +asmError x64Parser::Opcode485(x64Operand &operand) { - operand.values[23] = OpcodeCodings483_23; - operand.values[36] = OpcodeCodings483_36; + operand.values[23] = OpcodeCodings485_23; + operand.values[36] = OpcodeCodings485_36; asmError rv; { rv = Opcode21(operand); } return rv; } -asmError x64Parser::Opcode484(x64Operand &operand) +asmError x64Parser::Opcode486(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8529, operand); + asmError rv = ParseOperands(tokenBranches8535, operand); return rv; } -Coding x64Parser::OpcodeCodings485_23[] = { +Coding x64Parser::OpcodeCodings487_23[] = { { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings485_36[] = { +Coding x64Parser::OpcodeCodings487_36[] = { { CODING_NAME("movhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode485(x64Operand &operand) +asmError x64Parser::Opcode487(x64Operand &operand) { - operand.values[23] = OpcodeCodings485_23; - operand.values[36] = OpcodeCodings485_36; + operand.values[23] = OpcodeCodings487_23; + operand.values[36] = OpcodeCodings487_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings486_23[] = { +Coding x64Parser::OpcodeCodings488_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings486_36[] = { +Coding x64Parser::OpcodeCodings488_36[] = { { CODING_NAME("movhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode486(x64Operand &operand) +asmError x64Parser::Opcode488(x64Operand &operand) { - operand.values[23] = OpcodeCodings486_23; - operand.values[36] = OpcodeCodings486_36; + operand.values[23] = OpcodeCodings488_23; + operand.values[36] = OpcodeCodings488_36; asmError rv; { rv = Opcode22(operand); } return rv; } -asmError x64Parser::Opcode487(x64Operand &operand) +asmError x64Parser::Opcode489(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8535, operand); + asmError rv = ParseOperands(tokenBranches8541, operand); return rv; } -Coding x64Parser::OpcodeCodings488_23[] = { +Coding x64Parser::OpcodeCodings490_23[] = { { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings488_36[] = { +Coding x64Parser::OpcodeCodings490_36[] = { { CODING_NAME("movlpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode488(x64Operand &operand) +asmError x64Parser::Opcode490(x64Operand &operand) { - operand.values[23] = OpcodeCodings488_23; - operand.values[36] = OpcodeCodings488_36; + operand.values[23] = OpcodeCodings490_23; + operand.values[36] = OpcodeCodings490_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings489_23[] = { +Coding x64Parser::OpcodeCodings491_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings489_36[] = { +Coding x64Parser::OpcodeCodings491_36[] = { { CODING_NAME("movlps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode489(x64Operand &operand) +asmError x64Parser::Opcode491(x64Operand &operand) { - operand.values[23] = OpcodeCodings489_23; - operand.values[36] = OpcodeCodings489_36; + operand.values[23] = OpcodeCodings491_23; + operand.values[36] = OpcodeCodings491_36; asmError rv; { rv = Opcode22(operand); } return rv; } -Coding x64Parser::OpcodeCodings490_23[] = { +Coding x64Parser::OpcodeCodings492_23[] = { { CODING_NAME("movmskpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings490_19[] = { +Coding x64Parser::OpcodeCodings492_19[] = { { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movmskpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode490(x64Operand &operand) +asmError x64Parser::Opcode492(x64Operand &operand) { - operand.values[23] = OpcodeCodings490_23; - operand.values[19] = OpcodeCodings490_19; + operand.values[23] = OpcodeCodings492_23; + operand.values[19] = OpcodeCodings492_19; asmError rv; { rv = Opcode25(operand); } return rv; } -Coding x64Parser::OpcodeCodings491_23[] = { +Coding x64Parser::OpcodeCodings493_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings491_19[] = { +Coding x64Parser::OpcodeCodings493_19[] = { { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movmskps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 80, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode491(x64Operand &operand) +asmError x64Parser::Opcode493(x64Operand &operand) { - operand.values[23] = OpcodeCodings491_23; - operand.values[19] = OpcodeCodings491_19; + operand.values[23] = OpcodeCodings493_23; + operand.values[19] = OpcodeCodings493_19; asmError rv; { rv = Opcode25(operand); } return rv; } -asmError x64Parser::Opcode492(x64Operand &operand) +asmError x64Parser::Opcode494(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8543, operand); + asmError rv = ParseOperands(tokenBranches8549, operand); return rv; } -Coding x64Parser::OpcodeCodings493_19[] = { +Coding x64Parser::OpcodeCodings495_19[] = { { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movnti") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode493(x64Operand &operand) +asmError x64Parser::Opcode495(x64Operand &operand) { - operand.values[19] = OpcodeCodings493_19; - asmError rv = ParseOperands(tokenBranches8547, operand); + operand.values[19] = OpcodeCodings495_19; + asmError rv = ParseOperands(tokenBranches8553, operand); return rv; } -asmError x64Parser::Opcode494(x64Operand &operand) +asmError x64Parser::Opcode496(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8554, operand); + asmError rv = ParseOperands(tokenBranches8560, operand); return rv; } -asmError x64Parser::Opcode495(x64Operand &operand) +asmError x64Parser::Opcode497(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8558, operand); + asmError rv = ParseOperands(tokenBranches8564, operand); return rv; } -asmError x64Parser::Opcode496(x64Operand &operand) +asmError x64Parser::Opcode498(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8562, operand); + asmError rv = ParseOperands(tokenBranches8568, operand); return rv; } -asmError x64Parser::Opcode497(x64Operand &operand) +asmError x64Parser::Opcode499(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8566, operand); + asmError rv = ParseOperands(tokenBranches8572, operand); return rv; } -Coding x64Parser::OpcodeCodings498_23[] = { +Coding x64Parser::OpcodeCodings500_23[] = { { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings498_19[] = { +Coding x64Parser::OpcodeCodings500_19[] = { { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movshdup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode498(x64Operand &operand) +asmError x64Parser::Opcode500(x64Operand &operand) { - operand.values[23] = OpcodeCodings498_23; - operand.values[19] = OpcodeCodings498_19; + operand.values[23] = OpcodeCodings500_23; + operand.values[19] = OpcodeCodings500_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings499_23[] = { +Coding x64Parser::OpcodeCodings501_23[] = { { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings499_19[] = { +Coding x64Parser::OpcodeCodings501_19[] = { { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("movsldup") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 18, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode499(x64Operand &operand) +asmError x64Parser::Opcode501(x64Operand &operand) { - operand.values[23] = OpcodeCodings499_23; - operand.values[19] = OpcodeCodings499_19; + operand.values[23] = OpcodeCodings501_23; + operand.values[19] = OpcodeCodings501_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings500_23[] = { +Coding x64Parser::OpcodeCodings502_23[] = { { CODING_NAME("movss") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings500_36[] = { +Coding x64Parser::OpcodeCodings502_36[] = { { CODING_NAME("movss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode500(x64Operand &operand) +asmError x64Parser::Opcode502(x64Operand &operand) { - operand.values[23] = OpcodeCodings500_23; - operand.values[36] = OpcodeCodings500_36; + operand.values[23] = OpcodeCodings502_23; + operand.values[36] = OpcodeCodings502_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings501_23[] = { +Coding x64Parser::OpcodeCodings503_23[] = { { CODING_NAME("movupd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings501_36[] = { +Coding x64Parser::OpcodeCodings503_36[] = { { CODING_NAME("movupd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode501(x64Operand &operand) +asmError x64Parser::Opcode503(x64Operand &operand) { - operand.values[23] = OpcodeCodings501_23; - operand.values[36] = OpcodeCodings501_36; + operand.values[23] = OpcodeCodings503_23; + operand.values[36] = OpcodeCodings503_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings502_23[] = { +Coding x64Parser::OpcodeCodings504_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings502_36[] = { +Coding x64Parser::OpcodeCodings504_36[] = { { CODING_NAME("movups") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 16, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode502(x64Operand &operand) +asmError x64Parser::Opcode504(x64Operand &operand) { - operand.values[23] = OpcodeCodings502_23; - operand.values[36] = OpcodeCodings502_36; + operand.values[23] = OpcodeCodings504_23; + operand.values[36] = OpcodeCodings504_36; asmError rv; { rv = Opcode20(operand); } return rv; } -Coding x64Parser::OpcodeCodings503_23[] = { +Coding x64Parser::OpcodeCodings505_23[] = { { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings503_19[] = { +Coding x64Parser::OpcodeCodings505_19[] = { { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("mpsadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 66, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode503(x64Operand &operand) +asmError x64Parser::Opcode505(x64Operand &operand) { - operand.values[23] = OpcodeCodings503_23; - operand.values[19] = OpcodeCodings503_19; + operand.values[23] = OpcodeCodings505_23; + operand.values[19] = OpcodeCodings505_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings504_23[] = { +Coding x64Parser::OpcodeCodings506_23[] = { { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings504_19[] = { +Coding x64Parser::OpcodeCodings506_19[] = { { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode504(x64Operand &operand) +asmError x64Parser::Opcode506(x64Operand &operand) { - operand.values[23] = OpcodeCodings504_23; - operand.values[19] = OpcodeCodings504_19; + operand.values[23] = OpcodeCodings506_23; + operand.values[19] = OpcodeCodings506_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings505_23[] = { +Coding x64Parser::OpcodeCodings507_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings505_19[] = { +Coding x64Parser::OpcodeCodings507_19[] = { { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode505(x64Operand &operand) +asmError x64Parser::Opcode507(x64Operand &operand) { - operand.values[23] = OpcodeCodings505_23; - operand.values[19] = OpcodeCodings505_19; + operand.values[23] = OpcodeCodings507_23; + operand.values[19] = OpcodeCodings507_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings506_23[] = { +Coding x64Parser::OpcodeCodings508_23[] = { { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings506_19[] = { +Coding x64Parser::OpcodeCodings508_19[] = { { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode506(x64Operand &operand) +asmError x64Parser::Opcode508(x64Operand &operand) { - operand.values[23] = OpcodeCodings506_23; - operand.values[19] = OpcodeCodings506_19; + operand.values[23] = OpcodeCodings508_23; + operand.values[19] = OpcodeCodings508_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings507_23[] = { +Coding x64Parser::OpcodeCodings509_23[] = { { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings507_19[] = { +Coding x64Parser::OpcodeCodings509_19[] = { { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("mulss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 89, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode507(x64Operand &operand) +asmError x64Parser::Opcode509(x64Operand &operand) { - operand.values[23] = OpcodeCodings507_23; - operand.values[19] = OpcodeCodings507_19; + operand.values[23] = OpcodeCodings509_23; + operand.values[19] = OpcodeCodings509_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings508_23[] = { +Coding x64Parser::OpcodeCodings510_23[] = { { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings508_19[] = { +Coding x64Parser::OpcodeCodings510_19[] = { { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("orpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode508(x64Operand &operand) +asmError x64Parser::Opcode510(x64Operand &operand) { - operand.values[23] = OpcodeCodings508_23; - operand.values[19] = OpcodeCodings508_19; + operand.values[23] = OpcodeCodings510_23; + operand.values[19] = OpcodeCodings510_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings509_23[] = { +Coding x64Parser::OpcodeCodings511_23[] = { { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings509_19[] = { +Coding x64Parser::OpcodeCodings511_19[] = { { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("orps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 86, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode509(x64Operand &operand) +asmError x64Parser::Opcode511(x64Operand &operand) { - operand.values[23] = OpcodeCodings509_23; - operand.values[19] = OpcodeCodings509_19; + operand.values[23] = OpcodeCodings511_23; + operand.values[19] = OpcodeCodings511_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings510_19[] = { +Coding x64Parser::OpcodeCodings512_19[] = { { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packssdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 107, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode510(x64Operand &operand) +asmError x64Parser::Opcode512(x64Operand &operand) { - operand.values[19] = OpcodeCodings510_19; + operand.values[19] = OpcodeCodings512_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings511_19[] = { +Coding x64Parser::OpcodeCodings513_19[] = { { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packsswb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 99, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode511(x64Operand &operand) +asmError x64Parser::Opcode513(x64Operand &operand) { - operand.values[19] = OpcodeCodings511_19; + operand.values[19] = OpcodeCodings513_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings512_23[] = { +Coding x64Parser::OpcodeCodings514_23[] = { { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings512_19[] = { +Coding x64Parser::OpcodeCodings514_19[] = { { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 56, 8, 0, 0, 0 }, { CODING_NAME("packusdw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 43, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode512(x64Operand &operand) +asmError x64Parser::Opcode514(x64Operand &operand) { - operand.values[23] = OpcodeCodings512_23; - operand.values[19] = OpcodeCodings512_19; + operand.values[23] = OpcodeCodings514_23; + operand.values[19] = OpcodeCodings514_19; asmError rv; { rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings513_19[] = { +Coding x64Parser::OpcodeCodings515_19[] = { { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 252, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode513(x64Operand &operand) +asmError x64Parser::Opcode515(x64Operand &operand) { - operand.values[19] = OpcodeCodings513_19; + operand.values[19] = OpcodeCodings515_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings514_19[] = { +Coding x64Parser::OpcodeCodings516_19[] = { { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 254, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode514(x64Operand &operand) +asmError x64Parser::Opcode516(x64Operand &operand) { - operand.values[19] = OpcodeCodings514_19; + operand.values[19] = OpcodeCodings516_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings515_19[] = { +Coding x64Parser::OpcodeCodings517_19[] = { { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 212, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode515(x64Operand &operand) +asmError x64Parser::Opcode517(x64Operand &operand) { - operand.values[19] = OpcodeCodings515_19; + operand.values[19] = OpcodeCodings517_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings516_19[] = { +Coding x64Parser::OpcodeCodings518_19[] = { { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode516(x64Operand &operand) +asmError x64Parser::Opcode518(x64Operand &operand) { - operand.values[19] = OpcodeCodings516_19; + operand.values[19] = OpcodeCodings518_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings517_19[] = { +Coding x64Parser::OpcodeCodings519_19[] = { { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 220, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode517(x64Operand &operand) +asmError x64Parser::Opcode519(x64Operand &operand) { - operand.values[19] = OpcodeCodings517_19; + operand.values[19] = OpcodeCodings519_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings518_19[] = { +Coding x64Parser::OpcodeCodings520_19[] = { { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 221, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode518(x64Operand &operand) +asmError x64Parser::Opcode520(x64Operand &operand) { - operand.values[19] = OpcodeCodings518_19; + operand.values[19] = OpcodeCodings520_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings519_19[] = { +Coding x64Parser::OpcodeCodings521_19[] = { { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("paddw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 253, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode519(x64Operand &operand) +asmError x64Parser::Opcode521(x64Operand &operand) { - operand.values[19] = OpcodeCodings519_19; + operand.values[19] = OpcodeCodings521_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings520_19[] = { +Coding x64Parser::OpcodeCodings522_19[] = { { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("palignr") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode520(x64Operand &operand) +asmError x64Parser::Opcode522(x64Operand &operand) { - operand.values[19] = OpcodeCodings520_19; - asmError rv = ParseOperands(tokenBranches8592, operand); + operand.values[19] = OpcodeCodings522_19; + asmError rv = ParseOperands(tokenBranches8598, operand); return rv; } -Coding x64Parser::OpcodeCodings521_19[] = { +Coding x64Parser::OpcodeCodings523_19[] = { { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pand") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 219, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode521(x64Operand &operand) +asmError x64Parser::Opcode523(x64Operand &operand) { - operand.values[19] = OpcodeCodings521_19; + operand.values[19] = OpcodeCodings523_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings522_19[] = { +Coding x64Parser::OpcodeCodings524_19[] = { { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pandn") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode522(x64Operand &operand) +asmError x64Parser::Opcode524(x64Operand &operand) { - operand.values[19] = OpcodeCodings522_19; + operand.values[19] = OpcodeCodings524_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings523_19[] = { +Coding x64Parser::OpcodeCodings525_19[] = { { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pavgb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode523(x64Operand &operand) +asmError x64Parser::Opcode525(x64Operand &operand) { - operand.values[19] = OpcodeCodings523_19; + operand.values[19] = OpcodeCodings525_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings524_19[] = { +Coding x64Parser::OpcodeCodings526_19[] = { { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pavgw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode524(x64Operand &operand) +asmError x64Parser::Opcode526(x64Operand &operand) { - operand.values[19] = OpcodeCodings524_19; + operand.values[19] = OpcodeCodings526_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings525_23[] = { +Coding x64Parser::OpcodeCodings527_23[] = { { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings525_19[] = { +Coding x64Parser::OpcodeCodings527_19[] = { { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pblendw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 14, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode525(x64Operand &operand) +asmError x64Parser::Opcode527(x64Operand &operand) { - operand.values[23] = OpcodeCodings525_23; - operand.values[19] = OpcodeCodings525_19; + operand.values[23] = OpcodeCodings527_23; + operand.values[19] = OpcodeCodings527_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings526_19[] = { +Coding x64Parser::OpcodeCodings528_19[] = { { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 116, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode526(x64Operand &operand) +asmError x64Parser::Opcode528(x64Operand &operand) { - operand.values[19] = OpcodeCodings526_19; + operand.values[19] = OpcodeCodings528_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings527_19[] = { +Coding x64Parser::OpcodeCodings529_19[] = { { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 118, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode527(x64Operand &operand) +asmError x64Parser::Opcode529(x64Operand &operand) { - operand.values[19] = OpcodeCodings527_19; + operand.values[19] = OpcodeCodings529_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings528_19[] = { +Coding x64Parser::OpcodeCodings530_19[] = { { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpeqw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 117, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode528(x64Operand &operand) +asmError x64Parser::Opcode530(x64Operand &operand) { - operand.values[19] = OpcodeCodings528_19; + operand.values[19] = OpcodeCodings530_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings529_23[] = { +Coding x64Parser::OpcodeCodings531_23[] = { { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings529_19[] = { +Coding x64Parser::OpcodeCodings531_19[] = { { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pcmpestri") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode529(x64Operand &operand) +asmError x64Parser::Opcode531(x64Operand &operand) { - operand.values[23] = OpcodeCodings529_23; - operand.values[19] = OpcodeCodings529_19; + operand.values[23] = OpcodeCodings531_23; + operand.values[19] = OpcodeCodings531_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings530_23[] = { +Coding x64Parser::OpcodeCodings532_23[] = { { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings530_19[] = { +Coding x64Parser::OpcodeCodings532_19[] = { { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, { CODING_NAME("pcmpestrm") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode530(x64Operand &operand) +asmError x64Parser::Opcode532(x64Operand &operand) { - operand.values[23] = OpcodeCodings530_23; - operand.values[19] = OpcodeCodings530_19; + operand.values[23] = OpcodeCodings532_23; + operand.values[19] = OpcodeCodings532_19; asmError rv; { rv = Opcode30(operand); } return rv; } -Coding x64Parser::OpcodeCodings531_19[] = { +Coding x64Parser::OpcodeCodings533_19[] = { { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 100, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode531(x64Operand &operand) +asmError x64Parser::Opcode533(x64Operand &operand) { - operand.values[19] = OpcodeCodings531_19; + operand.values[19] = OpcodeCodings533_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings532_19[] = { +Coding x64Parser::OpcodeCodings534_19[] = { { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode532(x64Operand &operand) +asmError x64Parser::Opcode534(x64Operand &operand) { - operand.values[19] = OpcodeCodings532_19; + operand.values[19] = OpcodeCodings534_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings533_19[] = { +Coding x64Parser::OpcodeCodings535_19[] = { { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pcmpgtw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 101, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -asmError x64Parser::Opcode533(x64Operand &operand) +asmError x64Parser::Opcode535(x64Operand &operand) { - operand.values[19] = OpcodeCodings533_19; + operand.values[19] = OpcodeCodings535_19; asmError rv; { rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings534_19[] = { +Coding x64Parser::OpcodeCodings536_19[] = { { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode534(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings534_19; - asmError rv = ParseOperands(tokenBranches8616, operand); - return rv; -} -Coding x64Parser::OpcodeCodings535_19[] = { - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -asmError x64Parser::Opcode535(x64Operand &operand) -{ - operand.values[19] = OpcodeCodings535_19; - asmError rv = ParseOperands(tokenBranches8622, operand); - return rv; -} -Coding x64Parser::OpcodeCodings536_19[] = { - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("pextrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode536(x64Operand &operand) { operand.values[19] = OpcodeCodings536_19; - asmError rv = ParseOperands(tokenBranches8628, operand); + asmError rv = ParseOperands(tokenBranches8622, operand); return rv; } +Coding x64Parser::OpcodeCodings537_19[] = { + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode537(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8634, operand); + operand.values[19] = OpcodeCodings537_19; + asmError rv = ParseOperands(tokenBranches8628, operand); return rv; } Coding x64Parser::OpcodeCodings538_19[] = { - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pextrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode538(x64Operand &operand) { operand.values[19] = OpcodeCodings538_19; - asmError rv = ParseOperands(tokenBranches8655, operand); + asmError rv = ParseOperands(tokenBranches8634, operand); return rv; } -Coding x64Parser::OpcodeCodings539_19[] = { - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode539(x64Operand &operand) { - operand.values[19] = OpcodeCodings539_19; - asmError rv = ParseOperands(tokenBranches8661, operand); + asmError rv = ParseOperands(tokenBranches8640, operand); return rv; } Coding x64Parser::OpcodeCodings540_19[] = { - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 32, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode540(x64Operand &operand) { operand.values[19] = OpcodeCodings540_19; - asmError rv = ParseOperands(tokenBranches8667, operand); + asmError rv = ParseOperands(tokenBranches8661, operand); return rv; } +Coding x64Parser::OpcodeCodings541_19[] = { + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode541(x64Operand &operand) { - asmError rv = ParseOperands(tokenBranches8673, operand); + operand.values[19] = OpcodeCodings541_19; + asmError rv = ParseOperands(tokenBranches8667, operand); return rv; } Coding x64Parser::OpcodeCodings542_19[] = { - { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("pinsrq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 34, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode542(x64Operand &operand) { operand.values[19] = OpcodeCodings542_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8673, operand); return rv; } -Coding x64Parser::OpcodeCodings543_19[] = { - { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; asmError x64Parser::Opcode543(x64Operand &operand) { - operand.values[19] = OpcodeCodings543_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8679, operand); return rv; } Coding x64Parser::OpcodeCodings544_19[] = { - { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaddwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 245, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode544(x64Operand &operand) @@ -45021,8 +45072,8 @@ asmError x64Parser::Opcode544(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings545_19[] = { - { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode545(x64Operand &operand) @@ -45035,8 +45086,8 @@ asmError x64Parser::Opcode545(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings546_19[] = { - { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmaxub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 222, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode546(x64Operand &operand) @@ -45049,19 +45100,22 @@ asmError x64Parser::Opcode546(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings547_19[] = { - { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode547(x64Operand &operand) { operand.values[19] = OpcodeCodings547_19; - asmError rv = ParseOperands(tokenBranches8699, operand); + asmError rv; + { + rv = Opcode27(operand); + } return rv; } Coding x64Parser::OpcodeCodings548_19[] = { - { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pminub") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 218, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode548(x64Operand &operand) @@ -45074,22 +45128,19 @@ asmError x64Parser::Opcode548(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings549_19[] = { - { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmovmskb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode549(x64Operand &operand) { operand.values[19] = OpcodeCodings549_19; - asmError rv; - { - rv = Opcode27(operand); - } + asmError rv = ParseOperands(tokenBranches8705, operand); return rv; } Coding x64Parser::OpcodeCodings550_19[] = { - { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhuw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode550(x64Operand &operand) @@ -45102,8 +45153,8 @@ asmError x64Parser::Opcode550(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings551_19[] = { - { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmulhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 229, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode551(x64Operand &operand) @@ -45116,8 +45167,8 @@ asmError x64Parser::Opcode551(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings552_19[] = { - { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmullw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 213, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode552(x64Operand &operand) @@ -45129,51 +45180,41 @@ asmError x64Parser::Opcode552(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings553_23[] = { - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings553_19[] = { - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pmuludq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 244, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode553(x64Operand &operand) { - operand.values[23] = OpcodeCodings553_23; operand.values[19] = OpcodeCodings553_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings554_23[] = { - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings554_19[] = { - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psadbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 246, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode554(x64Operand &operand) { - operand.values[23] = OpcodeCodings554_23; operand.values[19] = OpcodeCodings554_19; asmError rv; { - rv = Opcode28(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings555_23[] = { - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings555_19[] = { - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode555(x64Operand &operand) @@ -45187,69 +45228,68 @@ asmError x64Parser::Opcode555(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings556_23[] = { + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings556_19[] = { - { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufhw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode556(x64Operand &operand) { operand.values[23] = OpcodeCodings556_23; operand.values[19] = OpcodeCodings556_19; - asmError rv = ParseOperands(tokenBranches8720, operand); + asmError rv; + { + rv = Opcode28(operand); + } return rv; } -Coding x64Parser::OpcodeCodings557_39[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings557_36[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings557_23[] = { + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings557_37[] = { - { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings557_19[] = { + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshuflw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode557(x64Operand &operand) { - operand.values[39] = OpcodeCodings557_39; - operand.values[36] = OpcodeCodings557_36; - operand.values[37] = OpcodeCodings557_37; + operand.values[23] = OpcodeCodings557_23; + operand.values[19] = OpcodeCodings557_19; asmError rv; { - rv = Opcode29(operand); + rv = Opcode28(operand); } return rv; } Coding x64Parser::OpcodeCodings558_23[] = { - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings558_19[] = { - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pshufw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 112, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode558(x64Operand &operand) { operand.values[23] = OpcodeCodings558_23; operand.values[19] = OpcodeCodings558_19; - asmError rv = ParseOperands(tokenBranches8727, operand); + asmError rv = ParseOperands(tokenBranches8726, operand); return rv; } Coding x64Parser::OpcodeCodings559_39[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_36[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings559_37[] = { - { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, + { CODING_NAME("pslld") (Coding::Type)(Coding::valSpecified), 242, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode559(x64Operand &operand) @@ -45263,39 +45303,32 @@ asmError x64Parser::Opcode559(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings560_39[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings560_36[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings560_23[] = { + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings560_37[] = { - { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings560_19[] = { + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pslldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode560(x64Operand &operand) { - operand.values[39] = OpcodeCodings560_39; - operand.values[36] = OpcodeCodings560_36; - operand.values[37] = OpcodeCodings560_37; - asmError rv; - { - rv = Opcode29(operand); - } + operand.values[23] = OpcodeCodings560_23; + operand.values[19] = OpcodeCodings560_19; + asmError rv = ParseOperands(tokenBranches8733, operand); return rv; } Coding x64Parser::OpcodeCodings561_39[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_36[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings561_37[] = { - { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, + { CODING_NAME("psllq") (Coding::Type)(Coding::valSpecified), 243, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode561(x64Operand &operand) @@ -45310,15 +45343,15 @@ asmError x64Parser::Opcode561(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings562_39[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 6, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_36[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings562_37[] = { - { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, + { CODING_NAME("psllw") (Coding::Type)(Coding::valSpecified), 241, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode562(x64Operand &operand) @@ -45333,15 +45366,15 @@ asmError x64Parser::Opcode562(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings563_39[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_36[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings563_37[] = { - { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, + { CODING_NAME("psrad") (Coding::Type)(Coding::valSpecified), 226, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode563(x64Operand &operand) @@ -45355,32 +45388,39 @@ asmError x64Parser::Opcode563(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings564_23[] = { - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings564_39[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 4, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings564_19[] = { - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings564_36[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings564_37[] = { + { CODING_NAME("psraw") (Coding::Type)(Coding::valSpecified), 225, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode564(x64Operand &operand) { - operand.values[23] = OpcodeCodings564_23; - operand.values[19] = OpcodeCodings564_19; - asmError rv = ParseOperands(tokenBranches8736, operand); + operand.values[39] = OpcodeCodings564_39; + operand.values[36] = OpcodeCodings564_36; + operand.values[37] = OpcodeCodings564_37; + asmError rv; + { + rv = Opcode29(operand); + } return rv; } Coding x64Parser::OpcodeCodings565_39[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_36[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 114, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings565_37[] = { - { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, + { CODING_NAME("psrld") (Coding::Type)(Coding::valSpecified), 210, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode565(x64Operand &operand) @@ -45394,60 +45434,71 @@ asmError x64Parser::Opcode565(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings566_39[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; -Coding x64Parser::OpcodeCodings566_36[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings566_23[] = { + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::OpcodeCodings566_37[] = { - { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings566_19[] = { + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psrldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode566(x64Operand &operand) { - operand.values[39] = OpcodeCodings566_39; - operand.values[36] = OpcodeCodings566_36; - operand.values[37] = OpcodeCodings566_37; - asmError rv; - { - rv = Opcode29(operand); - } + operand.values[23] = OpcodeCodings566_23; + operand.values[19] = OpcodeCodings566_19; + asmError rv = ParseOperands(tokenBranches8742, operand); return rv; } -Coding x64Parser::OpcodeCodings567_19[] = { - { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings567_39[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings567_36[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 115, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings567_37[] = { + { CODING_NAME("psrlq") (Coding::Type)(Coding::valSpecified), 211, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode567(x64Operand &operand) { - operand.values[19] = OpcodeCodings567_19; + operand.values[39] = OpcodeCodings567_39; + operand.values[36] = OpcodeCodings567_36; + operand.values[37] = OpcodeCodings567_37; asmError rv; { - rv = Opcode27(operand); + rv = Opcode29(operand); } return rv; } -Coding x64Parser::OpcodeCodings568_19[] = { - { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, +Coding x64Parser::OpcodeCodings568_39[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 2, 0, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings568_36[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 113, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings568_37[] = { + { CODING_NAME("psrlw") (Coding::Type)(Coding::valSpecified), 209, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode568(x64Operand &operand) { - operand.values[19] = OpcodeCodings568_19; + operand.values[39] = OpcodeCodings568_39; + operand.values[36] = OpcodeCodings568_36; + operand.values[37] = OpcodeCodings568_37; asmError rv; { - rv = Opcode27(operand); + rv = Opcode29(operand); } return rv; } Coding x64Parser::OpcodeCodings569_19[] = { - { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 248, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode569(x64Operand &operand) @@ -45460,8 +45511,8 @@ asmError x64Parser::Opcode569(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings570_19[] = { - { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 250, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode570(x64Operand &operand) @@ -45474,8 +45525,8 @@ asmError x64Parser::Opcode570(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings571_19[] = { - { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 251, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode571(x64Operand &operand) @@ -45488,8 +45539,8 @@ asmError x64Parser::Opcode571(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings572_19[] = { - { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 232, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode572(x64Operand &operand) @@ -45502,8 +45553,8 @@ asmError x64Parser::Opcode572(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings573_19[] = { - { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubsw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode573(x64Operand &operand) @@ -45516,8 +45567,8 @@ asmError x64Parser::Opcode573(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings574_19[] = { - { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusb") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 216, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode574(x64Operand &operand) @@ -45530,8 +45581,8 @@ asmError x64Parser::Opcode574(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings575_19[] = { - { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("psubusw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 217, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode575(x64Operand &operand) @@ -45543,28 +45594,23 @@ asmError x64Parser::Opcode575(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings576_23[] = { - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings576_19[] = { - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode576(x64Operand &operand) { - operand.values[23] = OpcodeCodings576_23; operand.values[19] = OpcodeCodings576_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings577_19[] = { - { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode577(x64Operand &operand) @@ -45576,23 +45622,28 @@ asmError x64Parser::Opcode577(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings578_23[] = { + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; Coding x64Parser::OpcodeCodings578_19[] = { - { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode578(x64Operand &operand) { + operand.values[23] = OpcodeCodings578_23; operand.values[19] = OpcodeCodings578_19; asmError rv; { - rv = Opcode27(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings579_19[] = { - { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckhwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 105, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode579(x64Operand &operand) @@ -45604,28 +45655,23 @@ asmError x64Parser::Opcode579(x64Operand &operand) } return rv; } -Coding x64Parser::OpcodeCodings580_23[] = { - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings580_19[] = { - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklbw") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 96, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode580(x64Operand &operand) { - operand.values[23] = OpcodeCodings580_23; operand.values[19] = OpcodeCodings580_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings581_19[] = { - { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpckldq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 98, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode581(x64Operand &operand) @@ -45637,65 +45683,59 @@ asmError x64Parser::Opcode581(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings582_23[] = { + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; Coding x64Parser::OpcodeCodings582_19[] = { - { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklqdq") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode582(x64Operand &operand) { + operand.values[23] = OpcodeCodings582_23; operand.values[19] = OpcodeCodings582_19; asmError rv; { - rv = Opcode27(operand); + rv = Opcode19(operand); } return rv; } -Coding x64Parser::OpcodeCodings583_23[] = { - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings583_19[] = { - { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("punpcklwd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 97, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode583(x64Operand &operand) { - operand.values[23] = OpcodeCodings583_23; operand.values[19] = OpcodeCodings583_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } -Coding x64Parser::OpcodeCodings584_23[] = { - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, - { CODING_NAME("eot") Coding::eot }, -}; Coding x64Parser::OpcodeCodings584_19[] = { - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("pxor") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode584(x64Operand &operand) { - operand.values[23] = OpcodeCodings584_23; operand.values[19] = OpcodeCodings584_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode27(operand); } return rv; } Coding x64Parser::OpcodeCodings585_23[] = { - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings585_19[] = { - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode585(x64Operand &operand) @@ -45704,18 +45744,17 @@ asmError x64Parser::Opcode585(x64Operand &operand) operand.values[19] = OpcodeCodings585_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings586_23[] = { - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings586_19[] = { - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rcpss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 83, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode586(x64Operand &operand) @@ -45724,18 +45763,18 @@ asmError x64Parser::Opcode586(x64Operand &operand) operand.values[19] = OpcodeCodings586_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings587_23[] = { - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings587_19[] = { - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 9, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode587(x64Operand &operand) @@ -45749,13 +45788,13 @@ asmError x64Parser::Opcode587(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings588_23[] = { - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings588_19[] = { - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, - { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 8, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode588(x64Operand &operand) @@ -45769,11 +45808,13 @@ asmError x64Parser::Opcode588(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings589_23[] = { + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings589_19[] = { - { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode589(x64Operand &operand) @@ -45782,17 +45823,18 @@ asmError x64Parser::Opcode589(x64Operand &operand) operand.values[19] = OpcodeCodings589_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings590_23[] = { - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings590_19[] = { - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 58, 8, 0, 0, 0 }, + { CODING_NAME("roundss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 10, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode590(x64Operand &operand) @@ -45801,17 +45843,16 @@ asmError x64Parser::Opcode590(x64Operand &operand) operand.values[19] = OpcodeCodings590_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings591_23[] = { - { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings591_19[] = { - { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode591(x64Operand &operand) @@ -45820,16 +45861,17 @@ asmError x64Parser::Opcode591(x64Operand &operand) operand.values[19] = OpcodeCodings591_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings592_23[] = { + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings592_19[] = { - { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("rsqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 82, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode592(x64Operand &operand) @@ -45838,17 +45880,17 @@ asmError x64Parser::Opcode592(x64Operand &operand) operand.values[19] = OpcodeCodings592_19; asmError rv; { - rv = Opcode30(operand); + rv = Opcode19(operand); } return rv; } Coding x64Parser::OpcodeCodings593_23[] = { - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::valSpecified), 102, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings593_19[] = { - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode593(x64Operand &operand) @@ -45857,7 +45899,7 @@ asmError x64Parser::Opcode593(x64Operand &operand) operand.values[19] = OpcodeCodings593_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } @@ -45865,8 +45907,8 @@ Coding x64Parser::OpcodeCodings594_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings594_19[] = { - { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("shufps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 198, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode594(x64Operand &operand) @@ -45875,17 +45917,17 @@ asmError x64Parser::Opcode594(x64Operand &operand) operand.values[19] = OpcodeCodings594_19; asmError rv; { - rv = Opcode19(operand); + rv = Opcode30(operand); } return rv; } Coding x64Parser::OpcodeCodings595_23[] = { - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings595_19[] = { - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode595(x64Operand &operand) @@ -45899,12 +45941,11 @@ asmError x64Parser::Opcode595(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings596_23[] = { - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings596_19[] = { - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode596(x64Operand &operand) @@ -45918,12 +45959,12 @@ asmError x64Parser::Opcode596(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings597_23[] = { - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings597_19[] = { - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode597(x64Operand &operand) @@ -45937,11 +45978,12 @@ asmError x64Parser::Opcode597(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings598_23[] = { + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings598_19[] = { - { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("sqrtss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 81, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode598(x64Operand &operand) @@ -45955,12 +45997,12 @@ asmError x64Parser::Opcode598(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings599_23[] = { - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings599_19[] = { - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode599(x64Operand &operand) @@ -45974,12 +46016,11 @@ asmError x64Parser::Opcode599(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings600_23[] = { - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings600_19[] = { - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode600(x64Operand &operand) @@ -45993,12 +46034,12 @@ asmError x64Parser::Opcode600(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings601_23[] = { - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 242, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings601_19[] = { - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subsd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode601(x64Operand &operand) @@ -46012,11 +46053,12 @@ asmError x64Parser::Opcode601(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings602_23[] = { + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 243, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings602_19[] = { - { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("subss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 92, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode602(x64Operand &operand) @@ -46030,12 +46072,12 @@ asmError x64Parser::Opcode602(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings603_23[] = { - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings603_19[] = { - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomisd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode603(x64Operand &operand) @@ -46052,8 +46094,8 @@ Coding x64Parser::OpcodeCodings604_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings604_19[] = { - { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("ucomiss") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 46, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode604(x64Operand &operand) @@ -46067,12 +46109,12 @@ asmError x64Parser::Opcode604(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings605_23[] = { - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings605_19[] = { - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode605(x64Operand &operand) @@ -46089,8 +46131,8 @@ Coding x64Parser::OpcodeCodings606_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings606_19[] = { - { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpckhps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 21, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode606(x64Operand &operand) @@ -46104,12 +46146,12 @@ asmError x64Parser::Opcode606(x64Operand &operand) return rv; } Coding x64Parser::OpcodeCodings607_23[] = { - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings607_19[] = { - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode607(x64Operand &operand) @@ -46126,8 +46168,8 @@ Coding x64Parser::OpcodeCodings608_23[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::OpcodeCodings608_19[] = { - { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, - { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("unpcklps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; asmError x64Parser::Opcode608(x64Operand &operand) @@ -46140,14 +46182,41 @@ asmError x64Parser::Opcode608(x64Operand &operand) } return rv; } +Coding x64Parser::OpcodeCodings609_23[] = { + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 102, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings609_19[] = { + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorpd") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode609(x64Operand &operand) { - asmError rv = AERR_NONE; + operand.values[23] = OpcodeCodings609_23; + operand.values[19] = OpcodeCodings609_19; + asmError rv; + { + rv = Opcode19(operand); + } return rv; } +Coding x64Parser::OpcodeCodings610_23[] = { + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::OpcodeCodings610_19[] = { + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, + { CODING_NAME("xorps") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 87, 8, 0, 0, 0 }, + { CODING_NAME("eot") Coding::eot }, +}; asmError x64Parser::Opcode610(x64Operand &operand) { - asmError rv = AERR_NONE; + operand.values[23] = OpcodeCodings610_23; + operand.values[19] = OpcodeCodings610_19; + asmError rv; + { + rv = Opcode19(operand); + } return rv; } asmError x64Parser::Opcode611(x64Operand &operand) @@ -46200,7 +46269,17 @@ asmError x64Parser::Opcode620(x64Operand &operand) asmError rv = AERR_NONE; return rv; } -x64Parser::DispatchType x64Parser::DispatchTable[621] = { +asmError x64Parser::Opcode621(x64Operand &operand) +{ + asmError rv = AERR_NONE; + return rv; +} +asmError x64Parser::Opcode622(x64Operand &operand) +{ + asmError rv = AERR_NONE; + return rv; +} +x64Parser::DispatchType x64Parser::DispatchTable[623] = { NULL, NULL, NULL, @@ -46822,6 +46901,8 @@ x64Parser::DispatchType x64Parser::DispatchTable[621] = { &x64Parser::Opcode618, &x64Parser::Opcode619, &x64Parser::Opcode620, + &x64Parser::Opcode621, + &x64Parser::Opcode622, }; x64Token *x64Parser::addressTable[] = { @@ -55219,32 +55300,36 @@ Coding x64Parser::Coding501[] = { { CODING_NAME("eot") Coding::eot }, }; Coding x64Parser::Coding502[] = { + { Coding::native }, + { CODING_NAME("eot") Coding::eot }, +}; +Coding x64Parser::Coding503[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 153, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding503[] = { +Coding x64Parser::Coding504[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 200, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 27, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding504[] = { +Coding x64Parser::Coding505[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 155, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding505[] = { +Coding x64Parser::Coding506[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 223, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding506[] = { +Coding x64Parser::Coding507[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55256,7 +55341,7 @@ Coding x64Parser::Coding506[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding507[] = { +Coding x64Parser::Coding508[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55268,7 +55353,7 @@ Coding x64Parser::Coding507[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding508[] = { +Coding x64Parser::Coding509[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55280,7 +55365,7 @@ Coding x64Parser::Coding508[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding509[] = { +Coding x64Parser::Coding510[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55292,7 +55377,7 @@ Coding x64Parser::Coding509[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding510[] = { +Coding x64Parser::Coding511[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55304,7 +55389,7 @@ Coding x64Parser::Coding510[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 24, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding511[] = { +Coding x64Parser::Coding512[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 20, 0, 2, 0, '+' }, @@ -55316,79 +55401,79 @@ Coding x64Parser::Coding511[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding512[] = { +Coding x64Parser::Coding513[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 28, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding513[] = { +Coding x64Parser::Coding514[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding514[] = { +Coding x64Parser::Coding515[] = { { Coding::native }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding515[] = { +Coding x64Parser::Coding516[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 228, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding516[] = { +Coding x64Parser::Coding517[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding517[] = { +Coding x64Parser::Coding518[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding518[] = { +Coding x64Parser::Coding519[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 229, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding519[] = { +Coding x64Parser::Coding520[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 236, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding520[] = { +Coding x64Parser::Coding521[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding521[] = { +Coding x64Parser::Coding522[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding522[] = { +Coding x64Parser::Coding523[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 237, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding523[] = { +Coding x64Parser::Coding524[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding524[] = { +Coding x64Parser::Coding525[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55396,14 +55481,14 @@ Coding x64Parser::Coding524[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding525[] = { +Coding x64Parser::Coding526[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding526[] = { +Coding x64Parser::Coding527[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55411,14 +55496,14 @@ Coding x64Parser::Coding526[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding527[] = { +Coding x64Parser::Coding528[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding528[] = { +Coding x64Parser::Coding529[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55426,7 +55511,7 @@ Coding x64Parser::Coding528[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 108, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding529[] = { +Coding x64Parser::Coding530[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55434,7 +55519,7 @@ Coding x64Parser::Coding529[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding530[] = { +Coding x64Parser::Coding531[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55443,7 +55528,7 @@ Coding x64Parser::Coding530[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding531[] = { +Coding x64Parser::Coding532[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55451,7 +55536,7 @@ Coding x64Parser::Coding531[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding532[] = { +Coding x64Parser::Coding533[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55460,7 +55545,7 @@ Coding x64Parser::Coding532[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding533[] = { +Coding x64Parser::Coding534[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55468,7 +55553,7 @@ Coding x64Parser::Coding533[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding534[] = { +Coding x64Parser::Coding535[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55477,7 +55562,7 @@ Coding x64Parser::Coding534[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding535[] = { +Coding x64Parser::Coding536[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55485,7 +55570,7 @@ Coding x64Parser::Coding535[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding536[] = { +Coding x64Parser::Coding537[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55494,7 +55579,7 @@ Coding x64Parser::Coding536[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding537[] = { +Coding x64Parser::Coding538[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55502,7 +55587,7 @@ Coding x64Parser::Coding537[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding538[] = { +Coding x64Parser::Coding539[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55511,7 +55596,7 @@ Coding x64Parser::Coding538[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding539[] = { +Coding x64Parser::Coding540[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55519,7 +55604,7 @@ Coding x64Parser::Coding539[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding540[] = { +Coding x64Parser::Coding541[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55528,33 +55613,33 @@ Coding x64Parser::Coding540[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 109, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding541[] = { +Coding x64Parser::Coding542[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 205, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding542[] = { +Coding x64Parser::Coding543[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 207, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding543[] = { +Coding x64Parser::Coding544[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding544[] = { +Coding x64Parser::Coding545[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 227, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding545[] = { +Coding x64Parser::Coding546[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, @@ -55562,7 +55647,7 @@ Coding x64Parser::Coding545[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding546[] = { +Coding x64Parser::Coding547[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 234, 8, 0, 0, 0 }, @@ -55570,7 +55655,7 @@ Coding x64Parser::Coding546[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 2, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding547[] = { +Coding x64Parser::Coding548[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, @@ -55580,7 +55665,7 @@ Coding x64Parser::Coding547[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding548[] = { +Coding x64Parser::Coding549[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, @@ -55590,73 +55675,73 @@ Coding x64Parser::Coding548[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding549[] = { +Coding x64Parser::Coding550[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 235, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding550[] = { +Coding x64Parser::Coding551[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding551[] = { +Coding x64Parser::Coding552[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 233, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding552[] = { +Coding x64Parser::Coding553[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding553[] = { +Coding x64Parser::Coding554[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding554[] = { +Coding x64Parser::Coding555[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding555[] = { +Coding x64Parser::Coding556[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding556[] = { +Coding x64Parser::Coding557[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding557[] = { +Coding x64Parser::Coding558[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 172, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding558[] = { +Coding x64Parser::Coding559[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding559[] = { +Coding x64Parser::Coding560[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55664,14 +55749,14 @@ Coding x64Parser::Coding559[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding560[] = { +Coding x64Parser::Coding561[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding561[] = { +Coding x64Parser::Coding562[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55679,14 +55764,14 @@ Coding x64Parser::Coding561[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding562[] = { +Coding x64Parser::Coding563[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding563[] = { +Coding x64Parser::Coding564[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55694,14 +55779,14 @@ Coding x64Parser::Coding563[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding564[] = { +Coding x64Parser::Coding565[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding565[] = { +Coding x64Parser::Coding566[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55709,14 +55794,14 @@ Coding x64Parser::Coding565[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding566[] = { +Coding x64Parser::Coding567[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding567[] = { +Coding x64Parser::Coding568[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55724,14 +55809,14 @@ Coding x64Parser::Coding567[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding568[] = { +Coding x64Parser::Coding569[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding569[] = { +Coding x64Parser::Coding570[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55739,14 +55824,14 @@ Coding x64Parser::Coding569[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding570[] = { +Coding x64Parser::Coding571[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding571[] = { +Coding x64Parser::Coding572[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55754,14 +55839,14 @@ Coding x64Parser::Coding571[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding572[] = { +Coding x64Parser::Coding573[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding573[] = { +Coding x64Parser::Coding574[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -55769,38 +55854,38 @@ Coding x64Parser::Coding573[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding574[] = { +Coding x64Parser::Coding575[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 173, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding575[] = { +Coding x64Parser::Coding576[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 226, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding576[] = { +Coding x64Parser::Coding577[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 225, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding577[] = { +Coding x64Parser::Coding578[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 224, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 11, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding578[] = { +Coding x64Parser::Coding579[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding579[] = { +Coding x64Parser::Coding580[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55808,14 +55893,14 @@ Coding x64Parser::Coding579[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding580[] = { +Coding x64Parser::Coding581[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding581[] = { +Coding x64Parser::Coding582[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55823,7 +55908,7 @@ Coding x64Parser::Coding581[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding582[] = { +Coding x64Parser::Coding583[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55831,7 +55916,7 @@ Coding x64Parser::Coding582[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding583[] = { +Coding x64Parser::Coding584[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55840,7 +55925,7 @@ Coding x64Parser::Coding583[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding584[] = { +Coding x64Parser::Coding585[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55848,7 +55933,7 @@ Coding x64Parser::Coding584[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding585[] = { +Coding x64Parser::Coding586[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55857,7 +55942,7 @@ Coding x64Parser::Coding585[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding586[] = { +Coding x64Parser::Coding587[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55865,7 +55950,7 @@ Coding x64Parser::Coding586[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding587[] = { +Coding x64Parser::Coding588[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55874,7 +55959,7 @@ Coding x64Parser::Coding587[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding588[] = { +Coding x64Parser::Coding589[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55882,7 +55967,7 @@ Coding x64Parser::Coding588[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding589[] = { +Coding x64Parser::Coding590[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55891,7 +55976,7 @@ Coding x64Parser::Coding589[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding590[] = { +Coding x64Parser::Coding591[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 22, 5, 0, 0, 0 }, @@ -55899,7 +55984,7 @@ Coding x64Parser::Coding590[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding591[] = { +Coding x64Parser::Coding592[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55908,7 +55993,7 @@ Coding x64Parser::Coding591[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding592[] = { +Coding x64Parser::Coding593[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55917,7 +56002,7 @@ Coding x64Parser::Coding592[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding593[] = { +Coding x64Parser::Coding594[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55926,7 +56011,7 @@ Coding x64Parser::Coding593[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding594[] = { +Coding x64Parser::Coding595[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -55935,14 +56020,14 @@ Coding x64Parser::Coding594[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding595[] = { +Coding x64Parser::Coding596[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding596[] = { +Coding x64Parser::Coding597[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55950,14 +56035,14 @@ Coding x64Parser::Coding596[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding597[] = { +Coding x64Parser::Coding598[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 162, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding598[] = { +Coding x64Parser::Coding599[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55965,7 +56050,7 @@ Coding x64Parser::Coding598[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding599[] = { +Coding x64Parser::Coding600[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55973,7 +56058,7 @@ Coding x64Parser::Coding599[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding600[] = { +Coding x64Parser::Coding601[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -55982,7 +56067,7 @@ Coding x64Parser::Coding600[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding601[] = { +Coding x64Parser::Coding602[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -55990,7 +56075,7 @@ Coding x64Parser::Coding601[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding602[] = { +Coding x64Parser::Coding603[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -55999,7 +56084,7 @@ Coding x64Parser::Coding602[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding603[] = { +Coding x64Parser::Coding604[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56007,7 +56092,7 @@ Coding x64Parser::Coding603[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding604[] = { +Coding x64Parser::Coding605[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, @@ -56016,7 +56101,7 @@ Coding x64Parser::Coding604[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding605[] = { +Coding x64Parser::Coding606[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56024,7 +56109,7 @@ Coding x64Parser::Coding605[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding606[] = { +Coding x64Parser::Coding607[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, @@ -56033,53 +56118,53 @@ Coding x64Parser::Coding606[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding607[] = { +Coding x64Parser::Coding608[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding608[] = { +Coding x64Parser::Coding609[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding609[] = { +Coding x64Parser::Coding610[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding610[] = { +Coding x64Parser::Coding611[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding611[] = { +Coding x64Parser::Coding612[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding612[] = { +Coding x64Parser::Coding613[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 164, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding613[] = { +Coding x64Parser::Coding614[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding614[] = { +Coding x64Parser::Coding615[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56087,14 +56172,14 @@ Coding x64Parser::Coding614[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding615[] = { +Coding x64Parser::Coding616[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding616[] = { +Coding x64Parser::Coding617[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56102,14 +56187,14 @@ Coding x64Parser::Coding616[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding617[] = { +Coding x64Parser::Coding618[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding618[] = { +Coding x64Parser::Coding619[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56117,14 +56202,14 @@ Coding x64Parser::Coding618[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding619[] = { +Coding x64Parser::Coding620[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding620[] = { +Coding x64Parser::Coding621[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56132,14 +56217,14 @@ Coding x64Parser::Coding620[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding621[] = { +Coding x64Parser::Coding622[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding622[] = { +Coding x64Parser::Coding623[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56147,14 +56232,14 @@ Coding x64Parser::Coding622[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding623[] = { +Coding x64Parser::Coding624[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding624[] = { +Coding x64Parser::Coding625[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56162,14 +56247,14 @@ Coding x64Parser::Coding624[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding625[] = { +Coding x64Parser::Coding626[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding626[] = { +Coding x64Parser::Coding627[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56177,76 +56262,76 @@ Coding x64Parser::Coding626[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding627[] = { +Coding x64Parser::Coding628[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 165, 0, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding628[] = { +Coding x64Parser::Coding629[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 165, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding629[] = { +Coding x64Parser::Coding630[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 230, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding630[] = { +Coding x64Parser::Coding631[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding631[] = { +Coding x64Parser::Coding632[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding632[] = { +Coding x64Parser::Coding633[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 231, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 29, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding633[] = { +Coding x64Parser::Coding634[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 238, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding634[] = { +Coding x64Parser::Coding635[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding635[] = { +Coding x64Parser::Coding636[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding636[] = { +Coding x64Parser::Coding637[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 239, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding637[] = { +Coding x64Parser::Coding638[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding638[] = { +Coding x64Parser::Coding639[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56254,14 +56339,14 @@ Coding x64Parser::Coding638[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding639[] = { +Coding x64Parser::Coding640[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding640[] = { +Coding x64Parser::Coding641[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56269,14 +56354,14 @@ Coding x64Parser::Coding640[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding641[] = { +Coding x64Parser::Coding642[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding642[] = { +Coding x64Parser::Coding643[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56284,7 +56369,7 @@ Coding x64Parser::Coding642[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 110, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding643[] = { +Coding x64Parser::Coding644[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56292,7 +56377,7 @@ Coding x64Parser::Coding643[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding644[] = { +Coding x64Parser::Coding645[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56301,7 +56386,7 @@ Coding x64Parser::Coding644[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding645[] = { +Coding x64Parser::Coding646[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56309,7 +56394,7 @@ Coding x64Parser::Coding645[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding646[] = { +Coding x64Parser::Coding647[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56318,7 +56403,7 @@ Coding x64Parser::Coding646[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding647[] = { +Coding x64Parser::Coding648[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56326,7 +56411,7 @@ Coding x64Parser::Coding647[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding648[] = { +Coding x64Parser::Coding649[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56335,7 +56420,7 @@ Coding x64Parser::Coding648[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding649[] = { +Coding x64Parser::Coding650[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56343,7 +56428,7 @@ Coding x64Parser::Coding649[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding650[] = { +Coding x64Parser::Coding651[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56352,7 +56437,7 @@ Coding x64Parser::Coding650[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding651[] = { +Coding x64Parser::Coding652[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56360,7 +56445,7 @@ Coding x64Parser::Coding651[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding652[] = { +Coding x64Parser::Coding653[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56369,7 +56454,7 @@ Coding x64Parser::Coding652[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding653[] = { +Coding x64Parser::Coding654[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, @@ -56377,7 +56462,7 @@ Coding x64Parser::Coding653[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding654[] = { +Coding x64Parser::Coding655[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56386,7 +56471,7 @@ Coding x64Parser::Coding654[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 111, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding655[] = { +Coding x64Parser::Coding656[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56394,7 +56479,7 @@ Coding x64Parser::Coding655[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding656[] = { +Coding x64Parser::Coding657[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56402,7 +56487,7 @@ Coding x64Parser::Coding656[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding657[] = { +Coding x64Parser::Coding658[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56410,26 +56495,26 @@ Coding x64Parser::Coding657[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding658[] = { +Coding x64Parser::Coding659[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 161, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding659[] = { +Coding x64Parser::Coding660[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding660[] = { +Coding x64Parser::Coding661[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 7, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding661[] = { +Coding x64Parser::Coding662[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56437,7 +56522,7 @@ Coding x64Parser::Coding661[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding662[] = { +Coding x64Parser::Coding663[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56445,7 +56530,7 @@ Coding x64Parser::Coding662[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding663[] = { +Coding x64Parser::Coding664[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56453,131 +56538,131 @@ Coding x64Parser::Coding663[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding664[] = { +Coding x64Parser::Coding665[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 106, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding665[] = { +Coding x64Parser::Coding666[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding666[] = { +Coding x64Parser::Coding667[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding667[] = { +Coding x64Parser::Coding668[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 104, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding668[] = { +Coding x64Parser::Coding669[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { Coding::native }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding669[] = { +Coding x64Parser::Coding670[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { Coding::native }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding670[] = { +Coding x64Parser::Coding671[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 160, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding671[] = { +Coding x64Parser::Coding672[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 15, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding672[] = { +Coding x64Parser::Coding673[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 0, 2, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 3, 1, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 6, 3, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding673[] = { +Coding x64Parser::Coding674[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 194, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding674[] = { +Coding x64Parser::Coding675[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 195, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding675[] = { +Coding x64Parser::Coding676[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 202, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding676[] = { +Coding x64Parser::Coding677[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 203, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding677[] = { +Coding x64Parser::Coding678[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding678[] = { +Coding x64Parser::Coding679[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding679[] = { +Coding x64Parser::Coding680[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding680[] = { +Coding x64Parser::Coding681[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding681[] = { +Coding x64Parser::Coding682[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding682[] = { +Coding x64Parser::Coding683[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 174, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding683[] = { +Coding x64Parser::Coding684[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding684[] = { +Coding x64Parser::Coding685[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56585,14 +56670,14 @@ Coding x64Parser::Coding684[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding685[] = { +Coding x64Parser::Coding686[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding686[] = { +Coding x64Parser::Coding687[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56600,14 +56685,14 @@ Coding x64Parser::Coding686[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding687[] = { +Coding x64Parser::Coding688[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding688[] = { +Coding x64Parser::Coding689[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56615,14 +56700,14 @@ Coding x64Parser::Coding688[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding689[] = { +Coding x64Parser::Coding690[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding690[] = { +Coding x64Parser::Coding691[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56630,14 +56715,14 @@ Coding x64Parser::Coding690[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding691[] = { +Coding x64Parser::Coding692[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding692[] = { +Coding x64Parser::Coding693[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56645,14 +56730,14 @@ Coding x64Parser::Coding692[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding693[] = { +Coding x64Parser::Coding694[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding694[] = { +Coding x64Parser::Coding695[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56660,14 +56745,14 @@ Coding x64Parser::Coding694[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding695[] = { +Coding x64Parser::Coding696[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding696[] = { +Coding x64Parser::Coding697[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56675,59 +56760,59 @@ Coding x64Parser::Coding696[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding697[] = { +Coding x64Parser::Coding698[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 175, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding698[] = { +Coding x64Parser::Coding699[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding699[] = { +Coding x64Parser::Coding700[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding700[] = { +Coding x64Parser::Coding701[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding701[] = { +Coding x64Parser::Coding702[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding702[] = { +Coding x64Parser::Coding703[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding703[] = { +Coding x64Parser::Coding704[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 170, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding704[] = { +Coding x64Parser::Coding705[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding705[] = { +Coding x64Parser::Coding706[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56735,14 +56820,14 @@ Coding x64Parser::Coding705[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding706[] = { +Coding x64Parser::Coding707[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding707[] = { +Coding x64Parser::Coding708[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56750,14 +56835,14 @@ Coding x64Parser::Coding707[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding708[] = { +Coding x64Parser::Coding709[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding709[] = { +Coding x64Parser::Coding710[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56765,14 +56850,14 @@ Coding x64Parser::Coding709[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding710[] = { +Coding x64Parser::Coding711[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding711[] = { +Coding x64Parser::Coding712[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56780,14 +56865,14 @@ Coding x64Parser::Coding711[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding712[] = { +Coding x64Parser::Coding713[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding713[] = { +Coding x64Parser::Coding714[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56795,14 +56880,14 @@ Coding x64Parser::Coding713[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding714[] = { +Coding x64Parser::Coding715[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding715[] = { +Coding x64Parser::Coding716[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56810,14 +56895,14 @@ Coding x64Parser::Coding715[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding716[] = { +Coding x64Parser::Coding717[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding717[] = { +Coding x64Parser::Coding718[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 2, 8, 7, 0, 0 }, @@ -56825,40 +56910,40 @@ Coding x64Parser::Coding717[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding718[] = { +Coding x64Parser::Coding719[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 171, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding719[] = { +Coding x64Parser::Coding720[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 168, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding720[] = { +Coding x64Parser::Coding721[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 16, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding721[] = { +Coding x64Parser::Coding722[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding722[] = { +Coding x64Parser::Coding723[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 72, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 169, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect), 22, 32, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding723[] = { +Coding x64Parser::Coding724[] = { { CODING_NAME("unknown") Coding::stateFunc, 4 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56866,7 +56951,7 @@ Coding x64Parser::Coding723[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding724[] = { +Coding x64Parser::Coding725[] = { { CODING_NAME("unknown") Coding::stateFunc, 5 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 64, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56874,7 +56959,7 @@ Coding x64Parser::Coding724[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding725[] = { +Coding x64Parser::Coding726[] = { { CODING_NAME("unknown") Coding::stateFunc, 6 }, { CODING_NAME("unknown") (Coding::Type)(Coding::valSpecified), 72, 0, 0, 0, '+' }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 8, 0, 0, 0 }, @@ -56882,51 +56967,51 @@ Coding x64Parser::Coding725[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::indirect | Coding::fieldSpecified), 20, 3, 1, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding726[] = { +Coding x64Parser::Coding727[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding727[] = { +Coding x64Parser::Coding728[] = { { CODING_NAME("unknown") Coding::stateFunc, 1 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding728[] = { +Coding x64Parser::Coding729[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding729[] = { +Coding x64Parser::Coding730[] = { { CODING_NAME("unknown") Coding::stateFunc, 2 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding730[] = { +Coding x64Parser::Coding731[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding731[] = { +Coding x64Parser::Coding732[] = { { CODING_NAME("unknown") Coding::stateFunc, 3 }, { CODING_NAME("unknown") (Coding::Type)(Coding::indirect | Coding::fieldSpecified), 2, 0, 7, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding x64Parser::Coding732[] = { +Coding x64Parser::Coding733[] = { { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 64, 8, 0, 0, 0 }, { CODING_NAME("unknown") (Coding::Type)(Coding::bitSpecified | Coding::valSpecified), 215, 8, 0, 0, 0 }, { CODING_NAME("eot") Coding::eot }, }; -Coding * x64Parser::Codings[732] = { +Coding * x64Parser::Codings[733] = { x64Parser::Coding1, x64Parser::Coding2, x64Parser::Coding3, @@ -57659,6 +57744,7 @@ Coding * x64Parser::Codings[732] = { x64Parser::Coding730, x64Parser::Coding731, x64Parser::Coding732, + x64Parser::Coding733, }; Coding x64Parser::prefixCoding1[] = { { CODING_NAME("a16") Coding::stateFunc, 1 },